--- a/projects/openttd.vcproj Mon Nov 26 16:01:29 2007 +0000
+++ b/projects/openttd.vcproj Mon Nov 26 17:50:22 2007 +0000
@@ -198,6 +198,9 @@
RelativePath=".\..\src\console_cmds.cpp">
</File>
<File
+ RelativePath=".\..\src\core\bitmath_func.cpp">
+ </File>
+ <File
RelativePath=".\..\src\core\random_func.cpp">
</File>
<File
@@ -427,6 +430,9 @@
RelativePath=".\..\src\console.h">
</File>
<File
+ RelativePath=".\..\src\core\bitmath_func.hpp">
+ </File>
+ <File
RelativePath=".\..\src\core\math_func.hpp">
</File>
<File
--- a/projects/openttd_vs80.vcproj Mon Nov 26 16:01:29 2007 +0000
+++ b/projects/openttd_vs80.vcproj Mon Nov 26 17:50:22 2007 +0000
@@ -496,6 +496,10 @@
>
</File>
<File
+ RelativePath=".\..\src\core\bitmath_func.cpp"
+ >
+ </File>
+ <File
RelativePath=".\..\src\core\random_func.cpp"
>
</File>
@@ -800,6 +804,10 @@
>
</File>
<File
+ RelativePath=".\..\src\core\bitmath_func.hpp"
+ >
+ </File>
+ <File
RelativePath=".\..\src\core\math_func.hpp"
>
</File>
--- a/projects/openttd_vs90.vcproj Mon Nov 26 16:01:29 2007 +0000
+++ b/projects/openttd_vs90.vcproj Mon Nov 26 17:50:22 2007 +0000
@@ -493,6 +493,10 @@
>
</File>
<File
+ RelativePath=".\..\src\core\bitmath_func.cpp"
+ >
+ </File>
+ <File
RelativePath=".\..\src\core\random_func.cpp"
>
</File>
@@ -797,6 +801,10 @@
>
</File>
<File
+ RelativePath=".\..\src\core\bitmath_func.hpp"
+ >
+ </File>
+ <File
RelativePath=".\..\src\core\math_func.hpp"
>
</File>
--- a/source.list Mon Nov 26 16:01:29 2007 +0000
+++ b/source.list Mon Nov 26 17:50:22 2007 +0000
@@ -10,6 +10,7 @@
command.cpp
console.cpp
console_cmds.cpp
+core/bitmath_func.cpp
core/random_func.cpp
currency.cpp
date.cpp
@@ -108,6 +109,7 @@
cargotype.h
command.h
console.h
+core/bitmath_func.hpp
core/math_func.hpp
core/random_func.hpp
currency.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/core/bitmath_func.cpp Mon Nov 26 17:50:22 2007 +0000
@@ -0,0 +1,45 @@
+/* $Id$ */
+
+/** @file bitmath_func.cpp */
+
+#include "../stdafx.h"
+#include "bitmath_func.hpp"
+
+const uint8 _ffb_64[64] = {
+ 0, 0, 1, 0, 2, 0, 1, 0,
+ 3, 0, 1, 0, 2, 0, 1, 0,
+ 4, 0, 1, 0, 2, 0, 1, 0,
+ 3, 0, 1, 0, 2, 0, 1, 0,
+ 5, 0, 1, 0, 2, 0, 1, 0,
+ 3, 0, 1, 0, 2, 0, 1, 0,
+ 4, 0, 1, 0, 2, 0, 1, 0,
+ 3, 0, 1, 0, 2, 0, 1, 0,
+};
+
+/**
+ * Search the first set bit in a 32 bit variable.
+ *
+ * This algorithm is a static implementation of a log
+ * conguence search algorithm. It checks the first half
+ * if there is a bit set search there further. And this
+ * way further. If no bit is set return 0.
+ *
+ * @param x The value to search
+ * @param The position of the first bit set
+ */
+uint8 FindFirstBit(uint32 x)
+{
+ if (x == 0) return 0;
+ /* The macro FIND_FIRST_BIT is better to use when your x is
+ not more than 128. */
+
+ uint8 pos = 0;
+
+ if ((x & 0x0000ffff) == 0) { x >>= 16; pos += 16; }
+ if ((x & 0x000000ff) == 0) { x >>= 8; pos += 8; }
+ if ((x & 0x0000000f) == 0) { x >>= 4; pos += 4; }
+ if ((x & 0x00000003) == 0) { x >>= 2; pos += 2; }
+ if ((x & 0x00000001) == 0) { pos += 1; }
+
+ return pos;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/core/bitmath_func.hpp Mon Nov 26 17:50:22 2007 +0000
@@ -0,0 +1,278 @@
+/* $Id$ */
+
+/** @file bitmath_func.hpp */
+
+#ifndef BITMATH_FUNC_HPP
+#define BITMATH_FUNC_HPP
+
+/**
+ * Fetch n bits from x, started at bit s.
+ *
+ * This function can be used to fetch n bits from the value x. The
+ * s value set the startposition to read. The startposition is
+ * count from the LSB and starts at 0. The result starts at a
+ * LSB, as this isn't just an and-bitmask but also some
+ * bit-shifting operations. GB(0xFF, 2, 1) will so
+ * return 0x01 (0000 0001) instead of
+ * 0x04 (0000 0100).
+ *
+ * @param x The value to read some bits.
+ * @param s The startposition to read some bits.
+ * @param n The number of bits to read.
+ * @return The selected bits, aligned to a LSB.
+ */
+template<typename T> static inline uint GB(const T x, const uint8 s, const uint8 n)
+{
+ return (x >> s) & ((1U << n) - 1);
+}
+
+/** Set n bits from x starting at bit s to d
+ *
+ * This function sets n bits from x which started as bit s to the value of
+ * d. The parameters x, s and n works the same as the parameters of
+ * #GB. The result is saved in x again. Unused bits in the window
+ * provided by n are set to 0 if the value of b isn't "big" enough.
+ * This is not a bug, its a feature.
+ *
+ * @note Parameter x must be a variable as the result is saved there.
+ * @note To avoid unexpecting results the value of b should not use more
+ * space as the provided space of n bits (log2)
+ * @param x The variable to change some bits
+ * @param s The startposition for the new bits
+ * @param n The size/window for the new bits
+ * @param d The actually new bits to save in the defined position.
+ * @return The new value of x
+ */
+template<typename T, typename U> static inline T SB(T& x, const uint8 s, const uint8 n, const U d)
+{
+ x &= (T)(~(((1U << n) - 1) << s));
+ x |= (T)(d << s);
+ return x;
+}
+
+/** Add i to n bits of x starting at bit s.
+ *
+ * This add the value of i on n bits of x starting at bit s. The parameters x,
+ * s, i are similar to #GB besides x must be a variable as the result are
+ * saved there. An overflow does not affect the following bits of the given
+ * bit window and is simply ignored.
+ *
+ * @note Parameter x must be a variable as the result is saved there.
+ * @param x The variable to add some bits at some position
+ * @param s The startposition of the addition
+ * @param n The size/window for the addition
+ * @param i The value to add at the given startposition in the given window.
+ * @return The new value of x
+ */
+template<typename T, typename U> static inline T AB(T& x, const uint8 s, const uint8 n, const U i)
+{
+ const T mask = (T)(((1U << n) - 1) << s);
+ x = (T)((x & ~mask) | ((x + (i << s)) & mask));
+ return x;
+}
+
+/**
+ * Checks if a bit in a value is set.
+ *
+ * This function checks if a bit inside a value is set or not.
+ * The y value specific the position of the bit, started at the
+ * LSB and count from 0.
+ *
+ * @param x The value to check
+ * @param y The position of the bit to check, started from the LSB
+ * @return True if the bit is set, false else.
+ */
+template<typename T> static inline bool HasBit(const T x, const uint8 y)
+{
+ return (x & ((T)1U << y)) != 0;
+}
+
+/**
+ * Check several bits in a value.
+ *
+ * This macro checks if a value contains at least one bit of an other
+ * value.
+ *
+ * @param x The first value
+ * @param y The second value
+ * @return True if at least one bit is set in both values, false else.
+ */
+#define HASBITS(x, y) ((x) & (y))
+
+/**
+ * Set a bit in a variable.
+ *
+ * This function sets a bit in a variable. The variable is changed
+ * and the value is also returned. Parameter y defines the bit and
+ * starts at the LSB with 0.
+ *
+ * @param x The variable to set a bit
+ * @param y The bit position to set
+ * @return The new value of the old value with the bit set
+ */
+template<typename T> static inline T SetBit(T& x, const uint8 y)
+{
+ return x = (T)(x | (T)(1U << y));
+}
+
+/**
+ * Sets several bits in a variable.
+ *
+ * This macro sets several bits in a variable. The bits to set are provided
+ * by a value. The new value is also returned.
+ *
+ * @param x The variable to set some bits
+ * @param y The value with set bits for setting them in the variable
+ * @return The new value of x
+ */
+#define SETBITS(x, y) ((x) |= (y))
+
+/**
+ * Clears a bit in a variable.
+ *
+ * This function clears a bit in a variable. The variable is
+ * changed and the value is also returned. Parameter y defines the bit
+ * to clear and starts at the LSB with 0.
+ *
+ * @param x The variable to clear the bit
+ * @param y The bit position to clear
+ * @return The new value of the old value with the bit cleared
+ */
+template<typename T> static inline T ClrBit(T& x, const uint8 y)
+{
+ return x = (T)(x & ~((T)1U << y));
+}
+
+/**
+ * Clears several bits in a variable.
+ *
+ * This macro clears several bits in a variable. The bits to clear are
+ * provided by a value. The new value is also returned.
+ *
+ * @param x The variable to clear some bits
+ * @param y The value with set bits for clearing them in the variable
+ * @return The new value of x
+ */
+#define CLRBITS(x, y) ((x) &= ~(y))
+
+/**
+ * Toggles a bit in a variable.
+ *
+ * This function toggles a bit in a variable. The variable is
+ * changed and the value is also returned. Parameter y defines the bit
+ * to toggle and starts at the LSB with 0.
+ *
+ * @param x The varliable to toggle the bit
+ * @param y The bit position to toggle
+ * @return The new value of the old value with the bit toggled
+ */
+template<typename T> static inline T ToggleBit(T& x, const uint8 y)
+{
+ return x = (T)(x ^ (T)(1U << y));
+}
+
+
+/** Lookup table to check which bit is set in a 6 bit variable */
+extern const uint8 _ffb_64[64];
+
+/**
+ * Returns the first occure of a bit in a 6-bit value (from right).
+ *
+ * Returns the position of the first bit that is not zero, counted from the
+ * LSB. Ie, 110100 returns 2, 000001 returns 0, etc. When x == 0 returns
+ * 0.
+ *
+ * @param x The 6-bit value to check the first zero-bit
+ * @return The first position of a bit started from the LSB or 0 if x is 0.
+ */
+#define FIND_FIRST_BIT(x) _ffb_64[(x)]
+
+/**
+ * Finds the position of the first bit in an integer.
+ *
+ * This function returns the position of the first bit set in the
+ * integer. It does only check the bits of the bitmask
+ * 0x3F3F (0011111100111111) and checks only the
+ * bits of the bitmask 0x3F00 if and only if the
+ * lower part 0x00FF is 0. This results the bits at 0x00C0 must
+ * be also zero to check the bits at 0x3F00.
+ *
+ * @param value The value to check the first bits
+ * @return The position of the first bit which is set
+ * @see FIND_FIRST_BIT
+ */
+static inline uint8 FindFirstBit2x64(const int value)
+{
+ if ((value & 0xFF) == 0) {
+ return FIND_FIRST_BIT((value >> 8) & 0x3F) + 8;
+ } else {
+ return FIND_FIRST_BIT(value & 0x3F);
+ }
+}
+
+uint8 FindFirstBit(uint32 x);
+
+/**
+ * Clear the first bit in an integer.
+ *
+ * This function returns a value where the first bit (from LSB)
+ * is cleared.
+ * So, 110100 returns 110000, 000001 returns 000000, etc.
+ *
+ * @param value The value to clear the first bit
+ * @return The new value with the first bit cleared
+ */
+template<typename T> static inline T KillFirstBit(T value)
+{
+ return value &= (T)(value - 1);
+}
+
+/**
+ * Counts the number of set bits in a variable.
+ *
+ * @param value the value to count the number of bits in.
+ * @return the number of bits.
+ */
+template<typename T> static inline uint CountBits(T value)
+{
+ uint num;
+
+ /* This loop is only called once for every bit set by clearing the lowest
+ * bit in each loop. The number of bits is therefore equal to the number of
+ * times the loop was called. It was found at the following website:
+ * http://graphics.stanford.edu/~seander/bithacks.html */
+
+ for (num = 0; value != 0; num++) {
+ value &= (T)(value - 1);
+ }
+
+ return num;
+}
+
+/**
+ * ROtate x Left by n
+ *
+ * @note Assumes a byte has 8 bits
+ * @param x The value which we want to rotate
+ * @param n The number how many we waht to rotate
+ * @return A bit rotated number
+ */
+template<typename T> static inline T ROL(const T x, const uint8 n)
+{
+ return (T)(x << n | x >> (sizeof(x) * 8 - n));
+}
+
+/**
+ * ROtate x Right by n
+ *
+ * @note Assumes a byte has 8 bits
+ * @param x The value which we want to rotate
+ * @param n The number how many we waht to rotate
+ * @return A bit rotated number
+ */
+template<typename T> static inline T ROR(const T x, const uint8 n)
+{
+ return (T)(x >> n | x << (sizeof(x) * 8 - n));
+}
+
+#endif /* BITMATH_FUNC_HPP */
--- a/src/functions.h Mon Nov 26 16:01:29 2007 +0000
+++ b/src/functions.h Mon Nov 26 17:50:22 2007 +0000
@@ -105,8 +105,6 @@
uint GetTownRadiusGroup(const Town* t, TileIndex tile);
void ShowHighscoreTable(int difficulty, int8 rank);
-int FindFirstBit(uint32 x);
-
void AfterLoadTown();
void UpdatePatches();
void AskExitGame();
--- a/src/macros.h Mon Nov 26 16:01:29 2007 +0000
+++ b/src/macros.h Mon Nov 26 17:50:22 2007 +0000
@@ -5,176 +5,9 @@
#ifndef MACROS_H
#define MACROS_H
+#include "core/bitmath_func.hpp"
#include "core/math_func.hpp"
-/**
- * Fetch n bits from x, started at bit s.
- *
- * This function can be used to fetch n bits from the value x. The
- * s value set the startposition to read. The startposition is
- * count from the LSB and starts at 0. The result starts at a
- * LSB, as this isn't just an and-bitmask but also some
- * bit-shifting operations. GB(0xFF, 2, 1) will so
- * return 0x01 (0000 0001) instead of
- * 0x04 (0000 0100).
- *
- * @param x The value to read some bits.
- * @param s The startposition to read some bits.
- * @param n The number of bits to read.
- * @return The selected bits, aligned to a LSB.
- */
-template<typename T> static inline uint GB(const T x, const uint8 s, const uint8 n)
-{
- return (x >> s) & ((1U << n) - 1);
-}
-
-/** Set n bits from x starting at bit s to d
- *
- * This function sets n bits from x which started as bit s to the value of
- * d. The parameters x, s and n works the same as the parameters of
- * #GB. The result is saved in x again. Unused bits in the window
- * provided by n are set to 0 if the value of b isn't "big" enough.
- * This is not a bug, its a feature.
- *
- * @note Parameter x must be a variable as the result is saved there.
- * @note To avoid unexpecting results the value of b should not use more
- * space as the provided space of n bits (log2)
- * @param x The variable to change some bits
- * @param s The startposition for the new bits
- * @param n The size/window for the new bits
- * @param d The actually new bits to save in the defined position.
- * @return The new value of x
- */
-template<typename T, typename U> static inline T SB(T& x, const uint8 s, const uint8 n, const U d)
-{
- x &= (T)(~(((1U << n) - 1) << s));
- x |= (T)(d << s);
- return x;
-}
-
-/** Add i to n bits of x starting at bit s.
- *
- * This add the value of i on n bits of x starting at bit s. The parameters x,
- * s, i are similar to #GB besides x must be a variable as the result are
- * saved there. An overflow does not affect the following bits of the given
- * bit window and is simply ignored.
- *
- * @note Parameter x must be a variable as the result is saved there.
- * @param x The variable to add some bits at some position
- * @param s The startposition of the addition
- * @param n The size/window for the addition
- * @param i The value to add at the given startposition in the given window.
- * @return The new value of x
- */
-template<typename T, typename U> static inline T AB(T& x, const uint8 s, const uint8 n, const U i)
-{
- const T mask = (T)(((1U << n) - 1) << s);
- x = (T)((x & ~mask) | ((x + (i << s)) & mask));
- return x;
-}
-
-/**
- * Checks if a bit in a value is set.
- *
- * This function checks if a bit inside a value is set or not.
- * The y value specific the position of the bit, started at the
- * LSB and count from 0.
- *
- * @param x The value to check
- * @param y The position of the bit to check, started from the LSB
- * @return True if the bit is set, false else.
- */
-template<typename T> static inline bool HasBit(const T x, const uint8 y)
-{
- return (x & ((T)1U << y)) != 0;
-}
-
-/**
- * Set a bit in a variable.
- *
- * This function sets a bit in a variable. The variable is changed
- * and the value is also returned. Parameter y defines the bit and
- * starts at the LSB with 0.
- *
- * @param x The variable to set a bit
- * @param y The bit position to set
- * @return The new value of the old value with the bit set
- */
-template<typename T> static inline T SetBit(T& x, const uint8 y)
-{
- return x = (T)(x | (T)(1U << y));
-}
-
-/**
- * Clears a bit in a variable.
- *
- * This function clears a bit in a variable. The variable is
- * changed and the value is also returned. Parameter y defines the bit
- * to clear and starts at the LSB with 0.
- *
- * @param x The variable to clear the bit
- * @param y The bit position to clear
- * @return The new value of the old value with the bit cleared
- */
-template<typename T> static inline T ClrBit(T& x, const uint8 y)
-{
- return x = (T)(x & ~((T)1U << y));
-}
-
-/**
- * Toggles a bit in a variable.
- *
- * This function toggles a bit in a variable. The variable is
- * changed and the value is also returned. Parameter y defines the bit
- * to toggle and starts at the LSB with 0.
- *
- * @param x The varliable to toggle the bit
- * @param y The bit position to toggle
- * @return The new value of the old value with the bit toggled
- */
-template<typename T> static inline T ToggleBit(T& x, const uint8 y)
-{
- return x = (T)(x ^ (T)(1U << y));
-}
-
-
-/* checking more bits. Maybe unneccessary, but easy to use */
-/**
- * Check several bits in a value.
- *
- * This macro checks if a value contains at least one bit of an other
- * value.
- *
- * @param x The first value
- * @param y The second value
- * @return True if at least one bit is set in both values, false else.
- */
-#define HASBITS(x, y) ((x) & (y))
-
-/**
- * Sets several bits in a variable.
- *
- * This macro sets several bits in a variable. The bits to set are provided
- * by a value. The new value is also returned.
- *
- * @param x The variable to set some bits
- * @param y The value with set bits for setting them in the variable
- * @return The new value of x
- */
-#define SETBITS(x, y) ((x) |= (y))
-
-/**
- * Clears several bits in a variable.
- *
- * This macro clears several bits in a variable. The bits to clear are
- * provided by a value. The new value is also returned.
- *
- * @param x The variable to clear some bits
- * @param y The value with set bits for clearing them in the variable
- * @return The new value of x
- */
-#define CLRBITS(x, y) ((x) &= ~(y))
-
#define GENERAL_SPRITE_COLOR(color) ((color) + PALETTE_RECOLOR_START)
#define PLAYER_SPRITE_COLOR(owner) (GENERAL_SPRITE_COLOR(_player_colors[owner]))
@@ -187,80 +20,6 @@
*/
#define IS_CUSTOM_SPRITE(sprite) ((sprite) >= SPR_SIGNALS_BASE)
-extern const byte _ffb_64[64];
-
-/**
- * Returns the first occure of a bit in a 6-bit value (from right).
- *
- * Returns the position of the first bit that is not zero, counted from the
- * LSB. Ie, 110100 returns 2, 000001 returns 0, etc. When x == 0 returns
- * 0.
- *
- * @param x The 6-bit value to check the first zero-bit
- * @return The first position of a bit started from the LSB or 0 if x is 0.
- */
-#define FIND_FIRST_BIT(x) _ffb_64[(x)]
-
-/**
- * Finds the position of the first bit in an integer.
- *
- * This function returns the position of the first bit set in the
- * integer. It does only check the bits of the bitmask
- * 0x3F3F (0011111100111111) and checks only the
- * bits of the bitmask 0x3F00 if and only if the
- * lower part 0x00FF is 0. This results the bits at 0x00C0 must
- * be also zero to check the bits at 0x3F00.
- *
- * @param value The value to check the first bits
- * @return The position of the first bit which is set
- * @see FIND_FIRST_BIT
- */
-static inline int FindFirstBit2x64(int value)
-{
- if ((value & 0xFF) == 0) {
- return FIND_FIRST_BIT((value >> 8) & 0x3F) + 8;
- } else {
- return FIND_FIRST_BIT(value & 0x3F);
- }
-}
-
-/**
- * Clear the first bit in an integer.
- *
- * This function returns a value where the first bit (from LSB)
- * is cleared.
- * So, 110100 returns 110000, 000001 returns 000000, etc.
- *
- * @param value The value to clear the first bit
- * @return The new value with the first bit cleared
- */
-template<typename T> static inline T KillFirstBit(T value)
-{
- return value &= (T)(value - 1);
-}
-
-/**
- * Counts the number of set bits in a variable.
- *
- * @param value the value to count the number of bits in.
- * @return the number of bits.
- */
-template<typename T> static inline uint CountBits(T value)
-{
- uint num;
-
- /* This loop is only called once for every bit set by clearing the lowest
- * bit in each loop. The number of bits is therefore equal to the number of
- * times the loop was called. It was found at the following website:
- * http://graphics.stanford.edu/~seander/bithacks.html */
-
- for (num = 0; value != 0; num++) {
- value &= (T)(value - 1);
- }
-
- return num;
-}
-
#define for_each_bit(_i, _b) \
for (_i = 0; _b != 0; _i++, _b >>= 1) \
@@ -282,32 +41,6 @@
}
-/**
- * ROtate x Left by n
- *
- * @note Assumes a byte has 8 bits
- * @param x The value which we want to rotate
- * @param n The number how many we waht to rotate
- * @return A bit rotated number
- */
-template<typename T> static inline T ROL(const T x, const uint8 n)
-{
- return (T)(x << n | x >> (sizeof(x) * 8 - n));
-}
-
-/**
- * ROtate x Right by n
- *
- * @note Assumes a byte has 8 bits
- * @param x The value which we want to rotate
- * @param n The number how many we waht to rotate
- * @return A bit rotated number
- */
-template<typename T> static inline T ROR(const T x, const uint8 n)
-{
- return (T)(x >> n | x << (sizeof(x) * 8 - n));
-}
-
/** return the largest value that can be entered in a variable.
*/
#define MAX_UVALUE(type) ((type)~(type)0)
--- a/src/misc.cpp Mon Nov 26 16:01:29 2007 +0000
+++ b/src/misc.cpp Mon Nov 26 17:50:22 2007 +0000
@@ -205,24 +205,6 @@
}
-
-int FindFirstBit(uint32 value)
-{
- /* The macro FIND_FIRST_BIT is better to use when your value is
- not more than 128. */
- byte i = 0;
-
- if (value == 0) return 0;
-
- if ((value & 0x0000ffff) == 0) { value >>= 16; i += 16; }
- if ((value & 0x000000ff) == 0) { value >>= 8; i += 8; }
- if ((value & 0x0000000f) == 0) { value >>= 4; i += 4; }
- if ((value & 0x00000003) == 0) { value >>= 2; i += 2; }
- if ((value & 0x00000001) == 0) { i += 1; }
-
- return i;
-}
-
static void Save_NAME()
{
int i;
--- a/src/pathfind.cpp Mon Nov 26 16:01:29 2007 +0000
+++ b/src/pathfind.cpp Mon Nov 26 17:50:22 2007 +0000
@@ -230,17 +230,6 @@
return flotr.tile;
}
-const byte _ffb_64[64] = {
- 0, 0, 1, 0, 2, 0, 1, 0,
- 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0,
- 3, 0, 1, 0, 2, 0, 1, 0,
- 5, 0, 1, 0, 2, 0, 1, 0,
- 3, 0, 1, 0, 2, 0, 1, 0,
- 4, 0, 1, 0, 2, 0, 1, 0,
- 3, 0, 1, 0, 2, 0, 1, 0,
-};
-
static void TPFMode1(TrackPathFinder* tpf, TileIndex tile, DiagDirection direction);
/** Most code of the "Normal" case of TPF Mode 1; for signals special tricks