Files @ r20718:cc912091a170
Branch filter:

Location: cpp/openttd-patchpack/source/src/road_cmd.cpp - annotation

translators
(svn r25756) -Update from WebTranslator v3.0:
indonesian - 2 changes by UseYourIllusion
   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
r5584:545d748cc681
r5584:545d748cc681
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r9111:983de9c5a848
r6393:f9322fdf4c2c
r5584:545d748cc681
r6134:aa2aee9f9144
r8102:c3f2dd9e9116
r8224:194097dc7288
r8116:df67d3c5e4fd
r13840:e35c72858ba2
r8962:cfbdc736c8db
r6541:639dad125026
r7582:dfefb1216e6f
r8083:8cd2123a0c7c
r8114:866ed489ed98
r8144:1432edd15267
r8157:cf41aa22cd09
r8398:cf5cc32ab397
r10960:e97ebf9cf99b
r9009:e21a5dd1e60e
r14248:a9050881acd7
r9154:6e22da499a7e
r11034:b133414fb70f
r12239:4ede50b8e95b
r14248:a9050881acd7
r14248:a9050881acd7
r14477:752d803ed3be
r15350:38997da618b5
r15521:545d58d62089
r18557:96a9c31d64d1
r8083:8cd2123a0c7c
r8264:d493cb51fe8a
r7582:dfefb1216e6f
r10260:88d82a40120c
r10260:88d82a40120c
r10260:88d82a40120c
r10260:88d82a40120c
r9298:06e4a9703da1
r9298:06e4a9703da1
r12030:bf346482c342
r12030:bf346482c342
r9298:06e4a9703da1
r9298:06e4a9703da1
r9298:06e4a9703da1
r9298:06e4a9703da1
r17330:ddf80ef4b607
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r13499:0af2aac7f5aa
r8384:65a05dd0c46c
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r14802:858c389374a7
r9342:bbb4f112d5fd
r14802:858c389374a7
r5584:545d748cc681
r14802:858c389374a7
r5584:545d748cc681
r6751:a298378e2d72
r6751:a298378e2d72
r6751:a298378e2d72
r10207:a1fc2f2a33db
r14802:858c389374a7
r5584:545d748cc681
r6393:f9322fdf4c2c
r6393:f9322fdf4c2c
r14802:858c389374a7
r14802:858c389374a7
r14805:8c416234ced2
r14805:8c416234ced2
r14802:858c389374a7
r5584:545d748cc681
r14802:858c389374a7
r9342:bbb4f112d5fd
r14802:858c389374a7
r5584:545d748cc681
r9342:bbb4f112d5fd
r14802:858c389374a7
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r14800:3e915e992538
r14802:858c389374a7
r9342:bbb4f112d5fd
r6393:f9322fdf4c2c
r8734:d0410200053c
r8734:d0410200053c
r12077:baf868e4baf0
r12077:baf868e4baf0
r12077:baf868e4baf0
r12077:baf868e4baf0
r5584:545d748cc681
r9342:bbb4f112d5fd
r6393:f9322fdf4c2c
r6393:f9322fdf4c2c
r8734:d0410200053c
r6393:f9322fdf4c2c
r9413:fcf267325763
r9342:bbb4f112d5fd
r14802:858c389374a7
r9342:bbb4f112d5fd
r9342:bbb4f112d5fd
r5584:545d748cc681
r11106:7af0cd6ebe11
r5584:545d748cc681
r14802:858c389374a7
r5584:545d748cc681
r5584:545d748cc681
r8428:44e364e9d33f
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6483:d2923d9c6631
r8428:44e364e9d33f
r8428:44e364e9d33f
r8428:44e364e9d33f
r13060:e57594b0ca84
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r9341:c8e34c3b896e
r9341:c8e34c3b896e
r15454:a4eeacd020ee
r9341:c8e34c3b896e
r6679:1e9f8940e034
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r14721:f3e02434b6fb
r6679:1e9f8940e034
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r15608:7b580ec7448a
r15608:7b580ec7448a
r6679:1e9f8940e034
r14697:0b5e0f20b510
r8390:ef5ec525d36d
r14697:0b5e0f20b510
r14697:0b5e0f20b510
r15608:7b580ec7448a
r15608:7b580ec7448a
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r5584:545d748cc681
r14802:858c389374a7
r14802:858c389374a7
r5584:545d748cc681
r7370:ef5901b27aca
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r8230:33d57fce0ec2
r6679:1e9f8940e034
r19497:7f32e6905988
r19497:7f32e6905988
r19497:7f32e6905988
r8197:5f087672abf6
r6679:1e9f8940e034
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r6679:1e9f8940e034
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r14992:2648a73e4ab8
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r11247:c15ef8b37f5e
r17674:8ba1e586d6d1
r6714:c6995cca1e20
r6679:1e9f8940e034
r6679:1e9f8940e034
r8083:8cd2123a0c7c
r6679:1e9f8940e034
r6713:4a790cb78f8b
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r10128:f4940f705b87
r13476:add6db25d711
r6679:1e9f8940e034
r18981:fc315efa5642
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r8230:33d57fce0ec2
r6679:1e9f8940e034
r6679:1e9f8940e034
r5584:545d748cc681
r5584:545d748cc681
r18247:d176683304d1
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r6661:a60bd28b4b57
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r5584:545d748cc681
r12622:202e83a6cee7
r5584:545d748cc681
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r18133:84366df80b1a
r9413:fcf267325763
r8734:d0410200053c
r5584:545d748cc681
r5584:545d748cc681
r6393:f9322fdf4c2c
r8734:d0410200053c
r15454:a4eeacd020ee
r5584:545d748cc681
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r5584:545d748cc681
r9067:925f96cda5d5
r9067:925f96cda5d5
r10207:a1fc2f2a33db
r12030:bf346482c342
r12030:bf346482c342
r12030:bf346482c342
r9067:925f96cda5d5
r9067:925f96cda5d5
r9067:925f96cda5d5
r9067:925f96cda5d5
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r6662:60fd462fb415
r6661:a60bd28b4b57
r6661:a60bd28b4b57
r7536:851d38e350c3
r6661:a60bd28b4b57
r6661:a60bd28b4b57
r10289:a675c6e32e39
r10340:90705a3f079d
r11288:5c4e64d574de
r10340:90705a3f079d
r10289:a675c6e32e39
r6662:60fd462fb415
r6661:a60bd28b4b57
r7536:851d38e350c3
r6661:a60bd28b4b57
r5584:545d748cc681
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r6661:a60bd28b4b57
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8744:4e0fb659ed80
r14447:941a1226e642
r14447:941a1226e642
r14447:941a1226e642
r14447:941a1226e642
r14447:941a1226e642
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6697:f1b39d102e5e
r10340:90705a3f079d
r8563:f734b85d629c
r6697:f1b39d102e5e
r8187:e86eb57c9d06
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r11904:2acd21e9a0b6
r6661:a60bd28b4b57
r6661:a60bd28b4b57
r9789:5f422164dcce
r12460:1f2d22685cf3
r9789:5f422164dcce
r9789:5f422164dcce
r18735:ae53a5f2e6a9
r18735:ae53a5f2e6a9
r18735:ae53a5f2e6a9
r18735:ae53a5f2e6a9
r18735:ae53a5f2e6a9
r6661:a60bd28b4b57
r6661:a60bd28b4b57
r6661:a60bd28b4b57
r5584:545d748cc681
r11904:2acd21e9a0b6
r5584:545d748cc681
r13476:add6db25d711
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r8821:314401b58dd7
r5584:545d748cc681
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r18133:84366df80b1a
r7641:2b26b5be3fd7
r18133:84366df80b1a
r5584:545d748cc681
r7641:2b26b5be3fd7
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r7641:2b26b5be3fd7
r8744:4e0fb659ed80
r9413:fcf267325763
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r13760:ce615064f383
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r7641:2b26b5be3fd7
r5584:545d748cc681
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r5584:545d748cc681
r8744:4e0fb659ed80
r9413:fcf267325763
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r13748:140a77305928
r5584:545d748cc681
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r14450:8f83ebfe28cc
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6483:d2923d9c6631
r6134:aa2aee9f9144
r6661:a60bd28b4b57
r6764:88e9608d13b3
r5584:545d748cc681
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r18771:b0bbffcb9160
r8230:33d57fce0ec2
r8821:314401b58dd7
r5587:034e5e185dc2
r8744:4e0fb659ed80
r5584:545d748cc681
r5584:545d748cc681
r10207:a1fc2f2a33db
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r11288:5c4e64d574de
r10289:a675c6e32e39
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r19276:ad854f3053cd
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r10289:a675c6e32e39
r6134:aa2aee9f9144
r14994:b24d36ab6c4f
r5584:545d748cc681
r8690:9c16ab90d7b4
r8690:9c16ab90d7b4
r8690:9c16ab90d7b4
r15027:bb71fdfcc554
r7857:51b28ad77b78
r6661:a60bd28b4b57
r15027:bb71fdfcc554
r6764:88e9608d13b3
r18247:d176683304d1
r5584:545d748cc681
r16025:1f133eec9df1
r5584:545d748cc681
r7370:ef5901b27aca
r5584:545d748cc681
r6764:88e9608d13b3
r12622:202e83a6cee7
r6756:e6ed75d17a32
r8744:4e0fb659ed80
r8563:f734b85d629c
r5584:545d748cc681
r6661:a60bd28b4b57
r8734:d0410200053c
r6768:adee51ded6c1
r6764:88e9608d13b3
r11725:57bc99fdc1bc
r6764:88e9608d13b3
r5584:545d748cc681
r6764:88e9608d13b3
r12618:f5950d19ae82
r11725:57bc99fdc1bc
r6764:88e9608d13b3
r12618:f5950d19ae82
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r12618:f5950d19ae82
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r15560:1ce751e5c273
r8601:45db2d2005d0
r6764:88e9608d13b3
r12077:baf868e4baf0
r15560:1ce751e5c273
r6764:88e9608d13b3
r6764:88e9608d13b3
r6950:1a54b1afb12a
r6764:88e9608d13b3
r11725:57bc99fdc1bc
r5584:545d748cc681
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r5584:545d748cc681
r8744:4e0fb659ed80
r8744:4e0fb659ed80
r10128:f4940f705b87
r10130:205e8ead41fd
r11725:57bc99fdc1bc
r6661:a60bd28b4b57
r5584:545d748cc681
r5584:545d748cc681
r12760:308cf6c9a8ac
r5584:545d748cc681
r12760:308cf6c9a8ac
r12760:308cf6c9a8ac
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7928:a80e7e05d6c5
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8821:314401b58dd7
r15396:928b1cf244bb
r15396:928b1cf244bb
r15396:928b1cf244bb
r15396:928b1cf244bb
r8821:314401b58dd7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r5584:545d748cc681
r5584:545d748cc681
r11904:2acd21e9a0b6
r11904:2acd21e9a0b6
r18557:96a9c31d64d1
r18771:b0bbffcb9160
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18771:b0bbffcb9160
r18557:96a9c31d64d1
r18735:ae53a5f2e6a9
r18735:ae53a5f2e6a9
r18735:ae53a5f2e6a9
r18735:ae53a5f2e6a9
r18735:ae53a5f2e6a9
r6697:f1b39d102e5e
r12460:1f2d22685cf3
r18771:b0bbffcb9160
r9789:5f422164dcce
r8344:df24797cd78b
r5584:545d748cc681
r5584:545d748cc681
r13476:add6db25d711
r5584:545d748cc681
r5584:545d748cc681
r10129:c2bd7bc13408
r12760:308cf6c9a8ac
r10129:c2bd7bc13408
r10129:c2bd7bc13408
r10129:c2bd7bc13408
r10129:c2bd7bc13408
r10129:c2bd7bc13408
r10130:205e8ead41fd
r11725:57bc99fdc1bc
r15608:7b580ec7448a
r15608:7b580ec7448a
r6679:1e9f8940e034
r14697:0b5e0f20b510
r12760:308cf6c9a8ac
r19497:7f32e6905988
r12760:308cf6c9a8ac
r11725:57bc99fdc1bc
r8390:ef5ec525d36d
r14697:0b5e0f20b510
r14697:0b5e0f20b510
r15608:7b580ec7448a
r15608:7b580ec7448a
r6679:1e9f8940e034
r8821:314401b58dd7
r5584:545d748cc681
r16025:1f133eec9df1
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r5584:545d748cc681
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r8744:4e0fb659ed80
r6715:796412fbedbb
r8821:314401b58dd7
r6715:796412fbedbb
r11069:3f09c162966b
r14304:dc9cb5b9e881
r11725:57bc99fdc1bc
r6715:796412fbedbb
r6950:1a54b1afb12a
r6715:796412fbedbb
r5584:545d748cc681
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r8384:65a05dd0c46c
r16025:1f133eec9df1
r16025:1f133eec9df1
r18247:d176683304d1
r16025:1f133eec9df1
r8384:65a05dd0c46c
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r16025:1f133eec9df1
r8384:65a05dd0c46c
r8384:65a05dd0c46c
r8384:65a05dd0c46c
r8384:65a05dd0c46c
r5584:545d748cc681
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r8601:45db2d2005d0
r16025:1f133eec9df1
r16025:1f133eec9df1
r17890:237aba646ee3
r17890:237aba646ee3
r17890:237aba646ee3
r17890:237aba646ee3
r17890:237aba646ee3
r17890:237aba646ee3
r17890:237aba646ee3
r5584:545d748cc681
r5584:545d748cc681
r6679:1e9f8940e034
r7370:ef5901b27aca
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r18771:b0bbffcb9160
r10289:a675c6e32e39
r6679:1e9f8940e034
r6679:1e9f8940e034
r15608:7b580ec7448a
r15608:7b580ec7448a
r6679:1e9f8940e034
r6679:1e9f8940e034
r8197:5f087672abf6
r6679:1e9f8940e034
r6679:1e9f8940e034
r6661:a60bd28b4b57
r18771:b0bbffcb9160
r18771:b0bbffcb9160
r6679:1e9f8940e034
r17674:8ba1e586d6d1
r6679:1e9f8940e034
r6714:c6995cca1e20
r6679:1e9f8940e034
r8083:8cd2123a0c7c
r6679:1e9f8940e034
r6713:4a790cb78f8b
r6679:1e9f8940e034
r15608:7b580ec7448a
r15608:7b580ec7448a
r6679:1e9f8940e034
r6679:1e9f8940e034
r10129:c2bd7bc13408
r6679:1e9f8940e034
r18771:b0bbffcb9160
r6679:1e9f8940e034
r6679:1e9f8940e034
r6679:1e9f8940e034
r18771:b0bbffcb9160
r6679:1e9f8940e034
r5584:545d748cc681
r5584:545d748cc681
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r8563:f734b85d629c
r6764:88e9608d13b3
r8734:d0410200053c
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19683:1b9dd79cacb8
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r15610:623a23fb6560
r14242:3db0ce38c4cd
r6483:d2923d9c6631
r14242:3db0ce38c4cd
r5584:545d748cc681
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r5584:545d748cc681
r6662:60fd462fb415
r6764:88e9608d13b3
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r14242:3db0ce38c4cd
r5584:545d748cc681
r6764:88e9608d13b3
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r14242:3db0ce38c4cd
r15027:bb71fdfcc554
r7857:51b28ad77b78
r5584:545d748cc681
r14994:b24d36ab6c4f
r5584:545d748cc681
r14237:16c12e734991
r14237:16c12e734991
r5584:545d748cc681
r14242:3db0ce38c4cd
r14242:3db0ce38c4cd
r14242:3db0ce38c4cd
r7928:a80e7e05d6c5
r14242:3db0ce38c4cd
r14242:3db0ce38c4cd
r6764:88e9608d13b3
r5584:545d748cc681
r5584:545d748cc681
r6764:88e9608d13b3
r17674:8ba1e586d6d1
r6764:88e9608d13b3
r14237:16c12e734991
r6764:88e9608d13b3
r7928:a80e7e05d6c5
r6764:88e9608d13b3
r14819:7463361f569f
r14819:7463361f569f
r8821:314401b58dd7
r14819:7463361f569f
r14819:7463361f569f
r14819:7463361f569f
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r14242:3db0ce38c4cd
r5584:545d748cc681
r14237:16c12e734991
r5584:545d748cc681
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r19572:c5d4369f5c6d
r5584:545d748cc681
r8821:314401b58dd7
r14304:dc9cb5b9e881
r14819:7463361f569f
r14819:7463361f569f
r19572:c5d4369f5c6d
r14419:79cb0f50bd05
r14419:79cb0f50bd05
r5584:545d748cc681
r6764:88e9608d13b3
r7428:7a14b23c98c3
r7428:7a14b23c98c3
r7428:7a14b23c98c3
r14811:f744a88e8b05
r7428:7a14b23c98c3
r7428:7a14b23c98c3
r7428:7a14b23c98c3
r8390:ef5ec525d36d
r14811:f744a88e8b05
r7428:7a14b23c98c3
r7428:7a14b23c98c3
r7428:7a14b23c98c3
r6710:233729bf3e0d
r6710:233729bf3e0d
r6950:1a54b1afb12a
r6710:233729bf3e0d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r14242:3db0ce38c4cd
r5584:545d748cc681
r5584:545d748cc681
r14819:7463361f569f
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r14660:861ca27274d0
r6483:d2923d9c6631
r14660:861ca27274d0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6662:60fd462fb415
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r14660:861ca27274d0
r5584:545d748cc681
r8821:314401b58dd7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r14660:861ca27274d0
r15027:bb71fdfcc554
r6662:60fd462fb415
r5584:545d748cc681
r14994:b24d36ab6c4f
r5584:545d748cc681
r14237:16c12e734991
r14237:16c12e734991
r5584:545d748cc681
r5584:545d748cc681
r7928:a80e7e05d6c5
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7954:1bdc1342cf47
r5584:545d748cc681
r5584:545d748cc681
r8821:314401b58dd7
r8821:314401b58dd7
r14885:529f9d4925c9
r14885:529f9d4925c9
r6393:f9322fdf4c2c
r5584:545d748cc681
r14237:16c12e734991
r5584:545d748cc681
r7928:a80e7e05d6c5
r7928:a80e7e05d6c5
r5584:545d748cc681
r6393:f9322fdf4c2c
r5584:545d748cc681
r8821:314401b58dd7
r14304:dc9cb5b9e881
r7442:4170a1d41ea3
r8230:33d57fce0ec2
r8230:33d57fce0ec2
r14660:861ca27274d0
r7442:4170a1d41ea3
r7442:4170a1d41ea3
r8912:e8149d34f9d5
r7442:4170a1d41ea3
r7442:4170a1d41ea3
r14885:529f9d4925c9
r14885:529f9d4925c9
r15440:46e2c17b11f1
r15545:1f234e3ec76c
r7442:4170a1d41ea3
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r14237:16c12e734991
r5584:545d748cc681
r5584:545d748cc681
r14885:529f9d4925c9
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6483:d2923d9c6631
r6134:aa2aee9f9144
r6662:60fd462fb415
r5584:545d748cc681
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r5584:545d748cc681
r19944:25a78576fb5e
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r14994:b24d36ab6c4f
r15027:bb71fdfcc554
r6662:60fd462fb415
r7857:51b28ad77b78
r5584:545d748cc681
r18247:d176683304d1
r5584:545d748cc681
r9413:fcf267325763
r6134:aa2aee9f9144
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r8821:314401b58dd7
r14814:3d4abc0944bc
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r9036:e33a0264e0c3
r5584:545d748cc681
r5584:545d748cc681
r9036:e33a0264e0c3
r15350:38997da618b5
r5584:545d748cc681
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r12989:383937fd7eba
r5584:545d748cc681
r15160:11bc0f456aa7
r5584:545d748cc681
r14547:a4cc19b19cd3
r14547:a4cc19b19cd3
r5584:545d748cc681
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r14774:6075f6397e6f
r14774:6075f6397e6f
r14774:6075f6397e6f
r14774:6075f6397e6f
r5584:545d748cc681
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r5584:545d748cc681
r7389:43e81eaed707
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r12940:ba419d226b67
r7389:43e81eaed707
r7389:43e81eaed707
r5584:545d748cc681
r13476:add6db25d711
r5584:545d748cc681
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6661:a60bd28b4b57
r5584:545d748cc681
r10707:8a385eb35ca8
r14450:8f83ebfe28cc
r8230:33d57fce0ec2
r15152:07ec410a4abe
r15152:07ec410a4abe
r15152:07ec410a4abe
r15152:07ec410a4abe
r15152:07ec410a4abe
r6679:1e9f8940e034
r6679:1e9f8940e034
r5584:545d748cc681
r11725:57bc99fdc1bc
r5643:f4144f9d438e
r5584:545d748cc681
r5584:545d748cc681
r6814:46f66dcbc291
r8230:33d57fce0ec2
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r6814:46f66dcbc291
r6814:46f66dcbc291
r11247:c15ef8b37f5e
r8859:fae71d8f3cd6
r7928:a80e7e05d6c5
r8428:44e364e9d33f
r14304:dc9cb5b9e881
r6950:1a54b1afb12a
r6814:46f66dcbc291
r8859:fae71d8f3cd6
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6248:b940b09d7ab8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6248:b940b09d7ab8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8734:d0410200053c
r8734:d0410200053c
r8734:d0410200053c
r8734:d0410200053c
r8734:d0410200053c
r8734:d0410200053c
r8734:d0410200053c
r13499:0af2aac7f5aa
r5584:545d748cc681
r8734:d0410200053c
r8734:d0410200053c
r8734:d0410200053c
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r8744:4e0fb659ed80
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r18133:84366df80b1a
r5584:545d748cc681
r8744:4e0fb659ed80
r7335:93bf5f4b6ce4
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r9413:fcf267325763
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6541:639dad125026
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r8821:314401b58dd7
r6691:9c52dabf0c18
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r6691:9c52dabf0c18
r8528:2bfd692a054f
r18260:9616113792ef
r6691:9c52dabf0c18
r18251:23e77d038c74
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r8528:2bfd692a054f
r8528:2bfd692a054f
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r8821:314401b58dd7
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r18262:3bc00eb1e3da
r18245:fb370bf5a3c0
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r6764:88e9608d13b3
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8821:314401b58dd7
r5584:545d748cc681
r6661:a60bd28b4b57
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r5668:e62c2fbafb7b
r14309:f445232b17f6
r5584:545d748cc681
r5584:545d748cc681
r7335:93bf5f4b6ce4
r5584:545d748cc681
r6393:f9322fdf4c2c
r6393:f9322fdf4c2c
r17946:11058af6a630
r5584:545d748cc681
r5584:545d748cc681
r6691:9c52dabf0c18
r5584:545d748cc681
r8821:314401b58dd7
r5584:545d748cc681
r6541:639dad125026
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5668:e62c2fbafb7b
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5668:e62c2fbafb7b
r5584:545d748cc681
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6965:5d3a2349326a
r6965:5d3a2349326a
r6965:5d3a2349326a
r18245:fb370bf5a3c0
r6965:5d3a2349326a
r6965:5d3a2349326a
r6965:5d3a2349326a
r5584:545d748cc681
r6393:f9322fdf4c2c
r6691:9c52dabf0c18
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6393:f9322fdf4c2c
r7928:a80e7e05d6c5
r5584:545d748cc681
r8589:02a107580b36
r8589:02a107580b36
r18260:9616113792ef
r18260:9616113792ef
r8589:02a107580b36
r18251:23e77d038c74
r8589:02a107580b36
r8589:02a107580b36
r8589:02a107580b36
r8589:02a107580b36
r8647:f8fab7a33e4b
r14450:8f83ebfe28cc
r8647:f8fab7a33e4b
r6393:f9322fdf4c2c
r8821:314401b58dd7
r6764:88e9608d13b3
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10260:88d82a40120c
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7335:93bf5f4b6ce4
r5584:545d748cc681
r15383:dc9352538fcd
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r14477:752d803ed3be
r17018:ae1c162a5bc3
r17018:ae1c162a5bc3
r17018:ae1c162a5bc3
r17018:ae1c162a5bc3
r14477:752d803ed3be
r15383:dc9352538fcd
r15383:dc9352538fcd
r14477:752d803ed3be
r15383:dc9352538fcd
r15383:dc9352538fcd
r5584:545d748cc681
r15383:dc9352538fcd
r8821:314401b58dd7
r15383:dc9352538fcd
r15383:dc9352538fcd
r15383:dc9352538fcd
r15383:dc9352538fcd
r15383:dc9352538fcd
r15383:dc9352538fcd
r15383:dc9352538fcd
r15383:dc9352538fcd
r5584:545d748cc681
r5584:545d748cc681
r15383:dc9352538fcd
r9785:165707b7be50
r15383:dc9352538fcd
r15383:dc9352538fcd
r15383:dc9352538fcd
r15383:dc9352538fcd
r9785:165707b7be50
r9785:165707b7be50
r8563:f734b85d629c
r6697:f1b39d102e5e
r6697:f1b39d102e5e
r6697:f1b39d102e5e
r9154:6e22da499a7e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7335:93bf5f4b6ce4
r5584:545d748cc681
r14309:f445232b17f6
r5584:545d748cc681
r8821:314401b58dd7
r8563:f734b85d629c
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r6691:9c52dabf0c18
r8571:ede148e241b1
r14284:8fe3cab84763
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17625:366001a31c88
r17625:366001a31c88
r17625:366001a31c88
r17625:366001a31c88
r17625:366001a31c88
r17625:366001a31c88
r17625:366001a31c88
r6666:1116acea7c9c
r5584:545d748cc681
r14309:f445232b17f6
r8821:314401b58dd7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8571:ede148e241b1
r14284:8fe3cab84763
r5584:545d748cc681
r5584:545d748cc681
r11967:df0600d2c7e7
r11967:df0600d2c7e7
r10340:90705a3f079d
r10340:90705a3f079d
r10340:90705a3f079d
r12316:322a47b70dfd
r10289:a675c6e32e39
r10340:90705a3f079d
r10289:a675c6e32e39
r10340:90705a3f079d
r12991:ff20fa5b1c08
r10340:90705a3f079d
r10340:90705a3f079d
r12316:322a47b70dfd
r10340:90705a3f079d
r10340:90705a3f079d
r10340:90705a3f079d
r10289:a675c6e32e39
r10289:a675c6e32e39
r10289:a675c6e32e39
r10289:a675c6e32e39
r18261:0aa61ca7490f
r5584:545d748cc681
r5584:545d748cc681
r8563:f734b85d629c
r18260:9616113792ef
r18245:fb370bf5a3c0
r18125:7bcadab93511
r18125:7bcadab93511
r7335:93bf5f4b6ce4
r18245:fb370bf5a3c0
r18245:fb370bf5a3c0
r5584:545d748cc681
r18245:fb370bf5a3c0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7335:93bf5f4b6ce4
r5584:545d748cc681
r8563:f734b85d629c
r7335:93bf5f4b6ce4
r5584:545d748cc681
r7335:93bf5f4b6ce4
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9413:fcf267325763
r6357:de4229337c35
r18250:596efadc4b6d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6357:de4229337c35
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8563:f734b85d629c
r5584:545d748cc681
r10236:993bcc06ffa8
r5584:545d748cc681
r8308:25a889609773
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6393:f9322fdf4c2c
r5584:545d748cc681
r8308:25a889609773
r14450:8f83ebfe28cc
r18248:133cf25ab512
r5584:545d748cc681
r5584:545d748cc681
r19891:7fd9bf0868c4
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10647:62911ec68e89
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7641:2b26b5be3fd7
r9413:fcf267325763
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r8428:44e364e9d33f
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r7641:2b26b5be3fd7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10532:23a12232250b
r5584:545d748cc681
r10532:23a12232250b
r10532:23a12232250b
r10532:23a12232250b
r10532:23a12232250b
r5584:545d748cc681
r5584:545d748cc681
r8616:656db5986c9e
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r17726:380c68504830
r5584:545d748cc681
r5584:545d748cc681
r8616:656db5986c9e
r5584:545d748cc681
r8616:656db5986c9e
r8616:656db5986c9e
r5584:545d748cc681
r5584:545d748cc681
r8616:656db5986c9e
r8616:656db5986c9e
r5584:545d748cc681
r5584:545d748cc681
r8616:656db5986c9e
r5584:545d748cc681
r6683:4204f114c4c0
r8596:8d17f7fccce1
r6683:4204f114c4c0
r8596:8d17f7fccce1
r8596:8d17f7fccce1
r8596:8d17f7fccce1
r8616:656db5986c9e
r8596:8d17f7fccce1
r6764:88e9608d13b3
r8616:656db5986c9e
r8616:656db5986c9e
r6683:4204f114c4c0
r5584:545d748cc681
r5584:545d748cc681
r8596:8d17f7fccce1
r5584:545d748cc681
r8616:656db5986c9e
r8596:8d17f7fccce1
r8616:656db5986c9e
r8616:656db5986c9e
r8616:656db5986c9e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8596:8d17f7fccce1
r8596:8d17f7fccce1
r8596:8d17f7fccce1
r8616:656db5986c9e
r8596:8d17f7fccce1
r9224:0340c9af9930
r8616:656db5986c9e
r8596:8d17f7fccce1
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8616:656db5986c9e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r12622:202e83a6cee7
r12622:202e83a6cee7
r12622:202e83a6cee7
r12622:202e83a6cee7
r12622:202e83a6cee7
r12622:202e83a6cee7
r12622:202e83a6cee7
r12622:202e83a6cee7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r5584:545d748cc681
r9322:3f83b0034795
r12622:202e83a6cee7
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r14832:61030b59a8f3
r14832:61030b59a8f3
r14832:61030b59a8f3
r14832:61030b59a8f3
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r12622:202e83a6cee7
r9322:3f83b0034795
r15350:38997da618b5
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r12622:202e83a6cee7
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r11725:57bc99fdc1bc
r9322:3f83b0034795
r11725:57bc99fdc1bc
r9322:3f83b0034795
r11725:57bc99fdc1bc
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r9322:3f83b0034795
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6723:76bfb6080f45
r6723:76bfb6080f45
r6723:76bfb6080f45
r6723:76bfb6080f45
r6723:76bfb6080f45
r6723:76bfb6080f45
r5584:545d748cc681
r5584:545d748cc681
r8119:8fdb3a371896
r5584:545d748cc681
r5584:545d748cc681
r11979:a450390d0f16
r11979:a450390d0f16
r6857:1e07df806ef1
r12109:90df01928018
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r12861:5309cab2b296
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r5991:254bad51c6b2
r5584:545d748cc681
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5991:254bad51c6b2
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10207:a1fc2f2a33db
r5584:545d748cc681
r8563:f734b85d629c
r10207:a1fc2f2a33db
r10207:a1fc2f2a33db
r8519:a269c621b681
r6717:5a2b86d92023
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r10207:a1fc2f2a33db
r6717:5a2b86d92023
r6689:eb32642cbebb
r6661:a60bd28b4b57
r5584:545d748cc681
r5584:545d748cc681
r6661:a60bd28b4b57
r9341:c8e34c3b896e
r10207:a1fc2f2a33db
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r18557:96a9c31d64d1
r10207:a1fc2f2a33db
r6661:a60bd28b4b57
r6661:a60bd28b4b57
r5584:545d748cc681
r6661:a60bd28b4b57
r10207:a1fc2f2a33db
r10207:a1fc2f2a33db
r8598:ad76237b6806
r6689:eb32642cbebb
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r18556:3a067cfd3824
r10207:a1fc2f2a33db
r6689:eb32642cbebb
r6689:eb32642cbebb
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r18261:0aa61ca7490f
r7494:2e43e3339051
r9413:fcf267325763
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r18254:b88bdaaa822b
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r13748:140a77305928
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r10017:0fde3332744e
r14304:dc9cb5b9e881
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r18260:9616113792ef
r18254:b88bdaaa822b
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r18254:b88bdaaa822b
r18254:b88bdaaa822b
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r13748:140a77305928
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7582:dfefb1216e6f
r7494:2e43e3339051
r7494:2e43e3339051
r7494:2e43e3339051
r10260:88d82a40120c
r5587:034e5e185dc2
r10260:88d82a40120c
r18245:fb370bf5a3c0
r10260:88d82a40120c
r12235:f6faf5ffa926
r10260:88d82a40120c
r10260:88d82a40120c
r10260:88d82a40120c
r12244:a7666b5de168
r18314:21a3c3233272
r18314:21a3c3233272
r12248:7acc3688a3f0
r10260:88d82a40120c
r10260:88d82a40120c
r10260:88d82a40120c
r5584:545d748cc681
/* $Id$ */

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */

/** @file road_cmd.cpp Commands related to road tiles. */

#include "stdafx.h"
#include "cmd_helper.h"
#include "road_internal.h"
#include "viewport_func.h"
#include "command_func.h"
#include "pathfinder/yapf/yapf_cache.h"
#include "depot_base.h"
#include "newgrf.h"
#include "autoslope.h"
#include "tunnelbridge_map.h"
#include "strings_func.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "tunnelbridge.h"
#include "cheat_type.h"
#include "effectvehicle_func.h"
#include "effectvehicle_base.h"
#include "elrail_func.h"
#include "roadveh.h"
#include "town.h"
#include "company_base.h"
#include "core/random_func.hpp"
#include "newgrf_railtype.h"
#include "date_func.h"
#include "genworld.h"
#include "company_gui.h"

#include "table/strings.h"

/**
 * Verify whether a road vehicle is available.
 * @return \c true if at least one road vehicle is available, \c false if not
 */
bool RoadVehiclesAreBuilt()
{
	const RoadVehicle *rv;
	FOR_ALL_ROADVEHICLES(rv) return true;

	return false;
}

/** Invalid RoadBits on slopes.  */
static const RoadBits _invalid_tileh_slopes_road[2][15] = {
	/* The inverse of the mixable RoadBits on a leveled slope */
	{
		ROAD_NONE,         // SLOPE_FLAT
		ROAD_NE | ROAD_SE, // SLOPE_W
		ROAD_NE | ROAD_NW, // SLOPE_S

		ROAD_NE,           // SLOPE_SW
		ROAD_NW | ROAD_SW, // SLOPE_E
		ROAD_NONE,         // SLOPE_EW

		ROAD_NW,           // SLOPE_SE
		ROAD_NONE,         // SLOPE_WSE
		ROAD_SE | ROAD_SW, // SLOPE_N

		ROAD_SE,           // SLOPE_NW
		ROAD_NONE,         // SLOPE_NS
		ROAD_NONE,         // SLOPE_ENW

		ROAD_SW,           // SLOPE_NE
		ROAD_NONE,         // SLOPE_SEN
		ROAD_NONE          // SLOPE_NWS
	},
	/* The inverse of the allowed straight roads on a slope
	 * (with and without a foundation). */
	{
		ROAD_NONE, // SLOPE_FLAT
		ROAD_NONE, // SLOPE_W    Foundation
		ROAD_NONE, // SLOPE_S    Foundation

		ROAD_Y,    // SLOPE_SW
		ROAD_NONE, // SLOPE_E    Foundation
		ROAD_ALL,  // SLOPE_EW

		ROAD_X,    // SLOPE_SE
		ROAD_ALL,  // SLOPE_WSE
		ROAD_NONE, // SLOPE_N    Foundation

		ROAD_X,    // SLOPE_NW
		ROAD_ALL,  // SLOPE_NS
		ROAD_ALL,  // SLOPE_ENW

		ROAD_Y,    // SLOPE_NE
		ROAD_ALL,  // SLOPE_SEN
		ROAD_ALL   // SLOPE_NW
	}
};

static Foundation GetRoadFoundation(Slope tileh, RoadBits bits);

/**
 * Is it allowed to remove the given road bits from the given tile?
 * @param tile      the tile to remove the road from
 * @param remove    the roadbits that are going to be removed
 * @param owner     the actual owner of the roadbits of the tile
 * @param rt        the road type to remove the bits from
 * @param flags     command flags
 * @param town_check Shall the town rating checked/affected
 * @return A succeeded command when it is allowed to remove the road bits, a failed command otherwise.
 */
CommandCost CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, Owner owner, RoadType rt, DoCommandFlag flags, bool town_check)
{
	if (_game_mode == GM_EDITOR || remove == ROAD_NONE) return CommandCost();

	/* Water can always flood and towns can always remove "normal" road pieces.
	 * Towns are not be allowed to remove non "normal" road pieces, like tram
	 * tracks as that would result in trams that cannot turn. */
	if (_current_company == OWNER_WATER ||
			(rt == ROADTYPE_ROAD && !Company::IsValidID(_current_company))) return CommandCost();

	/* Only do the special processing if the road is owned
	 * by a town */
	if (owner != OWNER_TOWN) {
		if (owner == OWNER_NONE) return CommandCost();
		CommandCost ret = CheckOwnership(owner);
		return ret;
	}

	if (!town_check) return CommandCost();

	if (_cheats.magic_bulldozer.value) return CommandCost();

	Town *t = ClosestTownFromTile(tile, UINT_MAX);
	if (t == NULL) return CommandCost();

	/* check if you're allowed to remove the street owned by a town
	 * removal allowance depends on difficulty setting */
	CommandCost ret = CheckforTownRating(flags, t, ROAD_REMOVE);
	if (ret.Failed()) return ret;

	/* Get a bitmask of which neighbouring roads has a tile */
	RoadBits n = ROAD_NONE;
	RoadBits present = GetAnyRoadBits(tile, rt);
	if ((present & ROAD_NE) && (GetAnyRoadBits(TILE_ADDXY(tile, -1,  0), rt) & ROAD_SW)) n |= ROAD_NE;
	if ((present & ROAD_SE) && (GetAnyRoadBits(TILE_ADDXY(tile,  0,  1), rt) & ROAD_NW)) n |= ROAD_SE;
	if ((present & ROAD_SW) && (GetAnyRoadBits(TILE_ADDXY(tile,  1,  0), rt) & ROAD_NE)) n |= ROAD_SW;
	if ((present & ROAD_NW) && (GetAnyRoadBits(TILE_ADDXY(tile,  0, -1), rt) & ROAD_SE)) n |= ROAD_NW;

	int rating_decrease = RATING_ROAD_DOWN_STEP_EDGE;
	/* If 0 or 1 bits are set in n, or if no bits that match the bits to remove,
	 * then allow it */
	if (KillFirstBit(n) != ROAD_NONE && (n & remove) != ROAD_NONE) {
		/* you can remove all kind of roads with extra dynamite */
		if (!_settings_game.construction.extra_dynamite) {
			SetDParam(0, t->index);
			return_cmd_error(STR_ERROR_LOCAL_AUTHORITY_REFUSES_TO_ALLOW_THIS);
		}
		rating_decrease = RATING_ROAD_DOWN_STEP_INNER;
	}
	ChangeTownRating(t, rating_decrease, RATING_ROAD_MINIMUM, flags);

	return CommandCost();
}


/**
 * Delete a piece of road.
 * @param tile tile where to remove road from
 * @param flags operation to perform
 * @param pieces roadbits to remove
 * @param rt roadtype to remove
 * @param crossing_check should we check if there is a tram track when we are removing road from crossing?
 * @param town_check should we check if the town allows removal?
 */
static CommandCost RemoveRoad(TileIndex tile, DoCommandFlag flags, RoadBits pieces, RoadType rt, bool crossing_check, bool town_check = true)
{
	RoadTypes rts = GetRoadTypes(tile);
	/* The tile doesn't have the given road type */
	if (!HasBit(rts, rt)) return_cmd_error(rt == ROADTYPE_TRAM ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD);

	switch (GetTileType(tile)) {
		case MP_ROAD: {
			CommandCost ret = EnsureNoVehicleOnGround(tile);
			if (ret.Failed()) return ret;
			break;
		}

		case MP_STATION: {
			if (!IsDriveThroughStopTile(tile)) return CMD_ERROR;

			CommandCost ret = EnsureNoVehicleOnGround(tile);
			if (ret.Failed()) return ret;
			break;
		}

		case MP_TUNNELBRIDGE: {
			if (GetTunnelBridgeTransportType(tile) != TRANSPORT_ROAD) return CMD_ERROR;
			CommandCost ret = TunnelBridgeIsFree(tile, GetOtherTunnelBridgeEnd(tile));
			if (ret.Failed()) return ret;
			break;
		}

		default:
			return CMD_ERROR;
	}

	CommandCost ret = CheckAllowRemoveRoad(tile, pieces, GetRoadOwner(tile, rt), rt, flags, town_check);
	if (ret.Failed()) return ret;

	if (!IsTileType(tile, MP_ROAD)) {
		/* If it's the last roadtype, just clear the whole tile */
		if (rts == RoadTypeToRoadTypes(rt)) return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

		CommandCost cost(EXPENSES_CONSTRUCTION);
		if (IsTileType(tile, MP_TUNNELBRIDGE)) {
			/* Removing any roadbit in the bridge axis removes the roadtype (that's the behaviour remove-long-roads needs) */
			if ((AxisToRoadBits(DiagDirToAxis(GetTunnelBridgeDirection(tile))) & pieces) == ROAD_NONE) return_cmd_error(rt == ROADTYPE_TRAM ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD);

			TileIndex other_end = GetOtherTunnelBridgeEnd(tile);
			/* Pay for *every* tile of the bridge or tunnel */
			uint len = GetTunnelBridgeLength(other_end, tile) + 2;
			cost.AddCost(len * _price[PR_CLEAR_ROAD]);
			if (flags & DC_EXEC) {
				Company *c = Company::GetIfValid(GetRoadOwner(tile, rt));
				if (c != NULL) {
					/* A full diagonal road tile has two road bits. */
					c->infrastructure.road[rt] -= len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR;
					DirtyCompanyInfrastructureWindows(c->index);
				}

				SetRoadTypes(other_end, GetRoadTypes(other_end) & ~RoadTypeToRoadTypes(rt));
				SetRoadTypes(tile, GetRoadTypes(tile) & ~RoadTypeToRoadTypes(rt));

				/* If the owner of the bridge sells all its road, also move the ownership
				 * to the owner of the other roadtype. */
				RoadType other_rt = (rt == ROADTYPE_ROAD) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
				Owner other_owner = GetRoadOwner(tile, other_rt);
				if (other_owner != GetTileOwner(tile)) {
					SetTileOwner(tile, other_owner);
					SetTileOwner(other_end, other_owner);
				}

				/* Mark tiles dirty that have been repaved */
				MarkTileDirtyByTile(tile);
				MarkTileDirtyByTile(other_end);
				if (IsBridge(tile)) {
					TileIndexDiff delta = TileOffsByDiagDir(GetTunnelBridgeDirection(tile));

					for (TileIndex t = tile + delta; t != other_end; t += delta) MarkTileDirtyByTile(t);
				}
			}
		} else {
			assert(IsDriveThroughStopTile(tile));
			cost.AddCost(_price[PR_CLEAR_ROAD] * 2);
			if (flags & DC_EXEC) {
				Company *c = Company::GetIfValid(GetRoadOwner(tile, rt));
				if (c != NULL) {
					/* A full diagonal road tile has two road bits. */
					c->infrastructure.road[rt] -= 2;
					DirtyCompanyInfrastructureWindows(c->index);
				}
				SetRoadTypes(tile, GetRoadTypes(tile) & ~RoadTypeToRoadTypes(rt));
				MarkTileDirtyByTile(tile);
			}
		}
		return cost;
	}

	switch (GetRoadTileType(tile)) {
		case ROAD_TILE_NORMAL: {
			Slope tileh = GetTileSlope(tile);

			/* Steep slopes behave the same as slopes with one corner raised. */
			if (IsSteepSlope(tileh)) {
				tileh = SlopeWithOneCornerRaised(GetHighestSlopeCorner(tileh));
			}

			RoadBits present = GetRoadBits(tile, rt);
			const RoadBits other = GetOtherRoadBits(tile, rt);
			const Foundation f = GetRoadFoundation(tileh, present);

			if (HasRoadWorks(tile) && _current_company != OWNER_WATER) return_cmd_error(STR_ERROR_ROAD_WORKS_IN_PROGRESS);

			/* Autocomplete to a straight road
			 * @li if the bits of the other roadtypes result in another foundation
			 * @li if build on slopes is disabled */
			if ((IsStraightRoad(other) && (other & _invalid_tileh_slopes_road[0][tileh & SLOPE_ELEVATED]) != ROAD_NONE) ||
					(tileh != SLOPE_FLAT && !_settings_game.construction.build_on_slopes)) {
				pieces |= MirrorRoadBits(pieces);
			}

			/* limit the bits to delete to the existing bits. */
			pieces &= present;
			if (pieces == ROAD_NONE) return_cmd_error(rt == ROADTYPE_TRAM ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD);

			/* Now set present what it will be after the remove */
			present ^= pieces;

			/* Check for invalid RoadBit combinations on slopes */
			if (tileh != SLOPE_FLAT && present != ROAD_NONE &&
					(present & _invalid_tileh_slopes_road[0][tileh & SLOPE_ELEVATED]) == present) {
				return CMD_ERROR;
			}

			if (flags & DC_EXEC) {
				if (HasRoadWorks(tile)) {
					/* flooding tile with road works, don't forget to remove the effect vehicle too */
					assert(_current_company == OWNER_WATER);
					EffectVehicle *v;
					FOR_ALL_EFFECTVEHICLES(v) {
						if (TileVirtXY(v->x_pos, v->y_pos) == tile) {
							delete v;
						}
					}
				}

				Company *c = Company::GetIfValid(GetRoadOwner(tile, rt));
				if (c != NULL) {
					c->infrastructure.road[rt] -= CountBits(pieces);
					DirtyCompanyInfrastructureWindows(c->index);
				}

				if (present == ROAD_NONE) {
					RoadTypes rts = GetRoadTypes(tile) & ComplementRoadTypes(RoadTypeToRoadTypes(rt));
					if (rts == ROADTYPES_NONE) {
						/* Includes MarkTileDirtyByTile() */
						DoClearSquare(tile);
					} else {
						if (rt == ROADTYPE_ROAD && IsRoadOwner(tile, ROADTYPE_ROAD, OWNER_TOWN)) {
							/* Update nearest-town index */
							const Town *town = CalcClosestTownFromTile(tile);
							SetTownIndex(tile, town == NULL ? (TownID)INVALID_TOWN : town->index);
						}
						SetRoadBits(tile, ROAD_NONE, rt);
						SetRoadTypes(tile, rts);
						MarkTileDirtyByTile(tile);
					}
				} else {
					/* When bits are removed, you *always* end up with something that
					 * is not a complete straight road tile. However, trams do not have
					 * onewayness, so they cannot remove it either. */
					if (rt != ROADTYPE_TRAM) SetDisallowedRoadDirections(tile, DRD_NONE);
					SetRoadBits(tile, present, rt);
					MarkTileDirtyByTile(tile);
				}
			}

			CommandCost cost(EXPENSES_CONSTRUCTION, CountBits(pieces) * _price[PR_CLEAR_ROAD]);
			/* If we build a foundation we have to pay for it. */
			if (f == FOUNDATION_NONE && GetRoadFoundation(tileh, present) != FOUNDATION_NONE) cost.AddCost(_price[PR_BUILD_FOUNDATION]);

			return cost;
		}

		case ROAD_TILE_CROSSING: {
			if (pieces & ComplementRoadBits(GetCrossingRoadBits(tile))) {
				return CMD_ERROR;
			}

			/* Don't allow road to be removed from the crossing when there is tram;
			 * we can't draw the crossing without roadbits ;) */
			if (rt == ROADTYPE_ROAD && HasTileRoadType(tile, ROADTYPE_TRAM) && (flags & DC_EXEC || crossing_check)) return CMD_ERROR;

			if (flags & DC_EXEC) {
				Company *c = Company::GetIfValid(GetRoadOwner(tile, rt));
				if (c != NULL) {
					/* A full diagonal road tile has two road bits. */
					c->infrastructure.road[rt] -= 2;
					DirtyCompanyInfrastructureWindows(c->index);
				}

				Track railtrack = GetCrossingRailTrack(tile);
				RoadTypes rts = GetRoadTypes(tile) & ComplementRoadTypes(RoadTypeToRoadTypes(rt));
				if (rts == ROADTYPES_NONE) {
					TrackBits tracks = GetCrossingRailBits(tile);
					bool reserved = HasCrossingReservation(tile);
					MakeRailNormal(tile, GetTileOwner(tile), tracks, GetRailType(tile));
					if (reserved) SetTrackReservation(tile, tracks);

					/* Update rail count for level crossings. The plain track should still be accounted
					 * for, so only subtract the difference to the level crossing cost. */
					c = Company::GetIfValid(GetTileOwner(tile));
					if (c != NULL) c->infrastructure.rail[GetRailType(tile)] -= LEVELCROSSING_TRACKBIT_FACTOR - 1;
				} else {
					SetRoadTypes(tile, rts);
				}
				MarkTileDirtyByTile(tile);
				YapfNotifyTrackLayoutChange(tile, railtrack);
			}
			return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_ROAD] * 2);
		}

		default:
		case ROAD_TILE_DEPOT:
			return CMD_ERROR;
	}
}


/**
 * Calculate the costs for roads on slopes
 *  Aside modify the RoadBits to fit on the slopes
 *
 * @note The RoadBits are modified too!
 * @param tileh The current slope
 * @param pieces The RoadBits we want to add
 * @param existing The existent RoadBits of the current type
 * @param other The other existent RoadBits
 * @return The costs for these RoadBits on this slope
 */
static CommandCost CheckRoadSlope(Slope tileh, RoadBits *pieces, RoadBits existing, RoadBits other)
{
	/* Remove already build pieces */
	CLRBITS(*pieces, existing);

	/* If we can't build anything stop here */
	if (*pieces == ROAD_NONE) return CMD_ERROR;

	/* All RoadBit combos are valid on flat land */
	if (tileh == SLOPE_FLAT) return CommandCost();

	/* Steep slopes behave the same as slopes with one corner raised. */
	if (IsSteepSlope(tileh)) {
		tileh = SlopeWithOneCornerRaised(GetHighestSlopeCorner(tileh));
	}

	/* Save the merge of all bits of the current type */
	RoadBits type_bits = existing | *pieces;

	/* Roads on slopes */
	if (_settings_game.construction.build_on_slopes && (_invalid_tileh_slopes_road[0][tileh] & (other | type_bits)) == ROAD_NONE) {

		/* If we add leveling we've got to pay for it */
		if ((other | existing) == ROAD_NONE) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);

		return CommandCost();
	}

	/* Autocomplete uphill roads */
	*pieces |= MirrorRoadBits(*pieces);
	type_bits = existing | *pieces;

	/* Uphill roads */
	if (IsStraightRoad(type_bits) && (other == type_bits || other == ROAD_NONE) &&
			(_invalid_tileh_slopes_road[1][tileh] & (other | type_bits)) == ROAD_NONE) {

		/* Slopes with foundation ? */
		if (IsSlopeWithOneCornerRaised(tileh)) {

			/* Prevent build on slopes if it isn't allowed */
			if (_settings_game.construction.build_on_slopes) {

				/* If we add foundation we've got to pay for it */
				if ((other | existing) == ROAD_NONE) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);

				return CommandCost();
			}
		} else {
			if (HasExactlyOneBit(existing) && GetRoadFoundation(tileh, existing) == FOUNDATION_NONE) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
			return CommandCost();
		}
	}
	return CMD_ERROR;
}

/**
 * Build a piece of road.
 * @param tile tile where to build road
 * @param flags operation to perform
 * @param p1 bit 0..3 road pieces to build (RoadBits)
 *           bit 4..5 road type
 *           bit 6..7 disallowed directions to toggle
 * @param p2 the town that is building the road (0 if not applicable)
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdBuildRoad(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	CompanyID company = _current_company;
	CommandCost cost(EXPENSES_CONSTRUCTION);

	RoadBits existing = ROAD_NONE;
	RoadBits other_bits = ROAD_NONE;

	/* Road pieces are max 4 bitset values (NE, NW, SE, SW) and town can only be non-zero
	 * if a non-company is building the road */
	if ((Company::IsValidID(company) && p2 != 0) || (company == OWNER_TOWN && !Town::IsValidID(p2)) || (company == OWNER_DEITY && p2 != 0)) return CMD_ERROR;
	if (company != OWNER_TOWN) {
		const Town *town = CalcClosestTownFromTile(tile);
		p2 = (town != NULL) ? town->index : (TownID)INVALID_TOWN;

		if (company == OWNER_DEITY) {
			company = OWNER_TOWN;

			/* If we are not within a town, we are not owned by the town */
			if (town == NULL || DistanceSquare(tile, town->xy) > town->cache.squared_town_zone_radius[HZB_TOWN_EDGE]) {
				company = OWNER_NONE;
			}
		}
	}

	RoadBits pieces = Extract<RoadBits, 0, 4>(p1);

	/* do not allow building 'zero' road bits, code wouldn't handle it */
	if (pieces == ROAD_NONE) return CMD_ERROR;

	RoadType rt = Extract<RoadType, 4, 2>(p1);
	if (!IsValidRoadType(rt) || !ValParamRoadType(rt)) return CMD_ERROR;

	DisallowedRoadDirections toggle_drd = Extract<DisallowedRoadDirections, 6, 2>(p1);

	Slope tileh = GetTileSlope(tile);

	bool need_to_clear = false;
	switch (GetTileType(tile)) {
		case MP_ROAD:
			switch (GetRoadTileType(tile)) {
				case ROAD_TILE_NORMAL: {
					if (HasRoadWorks(tile)) return_cmd_error(STR_ERROR_ROAD_WORKS_IN_PROGRESS);

					other_bits = GetOtherRoadBits(tile, rt);
					if (!HasTileRoadType(tile, rt)) break;

					existing = GetRoadBits(tile, rt);
					bool crossing = !IsStraightRoad(existing | pieces);
					if (rt != ROADTYPE_TRAM && (GetDisallowedRoadDirections(tile) != DRD_NONE || toggle_drd != DRD_NONE) && crossing) {
						/* Junctions cannot be one-way */
						return_cmd_error(STR_ERROR_ONEWAY_ROADS_CAN_T_HAVE_JUNCTION);
					}
					if ((existing & pieces) == pieces) {
						/* We only want to set the (dis)allowed road directions */
						if (toggle_drd != DRD_NONE && rt != ROADTYPE_TRAM) {
							if (crossing) return_cmd_error(STR_ERROR_ONEWAY_ROADS_CAN_T_HAVE_JUNCTION);

							Owner owner = GetRoadOwner(tile, ROADTYPE_ROAD);
							if (owner != OWNER_NONE) {
								CommandCost ret = CheckOwnership(owner, tile);
								if (ret.Failed()) return ret;
							}

							DisallowedRoadDirections dis_existing = GetDisallowedRoadDirections(tile);
							DisallowedRoadDirections dis_new      = dis_existing ^ toggle_drd;

							/* We allow removing disallowed directions to break up
							 * deadlocks, but adding them can break articulated
							 * vehicles. As such, only when less is disallowed,
							 * i.e. bits are removed, we skip the vehicle check. */
							if (CountBits(dis_existing) <= CountBits(dis_new)) {
								CommandCost ret = EnsureNoVehicleOnGround(tile);
								if (ret.Failed()) return ret;
							}

							/* Ignore half built tiles */
							if ((flags & DC_EXEC) && rt != ROADTYPE_TRAM && IsStraightRoad(existing)) {
								SetDisallowedRoadDirections(tile, dis_new);
								MarkTileDirtyByTile(tile);
							}
							return CommandCost();
						}
						return_cmd_error(STR_ERROR_ALREADY_BUILT);
					}
					break;
				}

				case ROAD_TILE_CROSSING:
					other_bits = GetCrossingRoadBits(tile);
					if (pieces & ComplementRoadBits(other_bits)) goto do_clear;
					pieces = other_bits; // we need to pay for both roadbits

					if (HasTileRoadType(tile, rt)) return_cmd_error(STR_ERROR_ALREADY_BUILT);
					break;

				case ROAD_TILE_DEPOT:
					if ((GetAnyRoadBits(tile, rt) & pieces) == pieces) return_cmd_error(STR_ERROR_ALREADY_BUILT);
					goto do_clear;

				default: NOT_REACHED();
			}
			break;

		case MP_RAILWAY: {
			if (IsSteepSlope(tileh)) {
				return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
			}

			/* Level crossings may only be built on these slopes */
			if (!HasBit(VALID_LEVEL_CROSSING_SLOPES, tileh)) {
				return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
			}

			if (GetRailTileType(tile) != RAIL_TILE_NORMAL) goto do_clear;

			if (RailNoLevelCrossings(GetRailType(tile))) {
				return_cmd_error(STR_ERROR_CROSSING_DISALLOWED);
			}

			Axis roaddir;
			switch (GetTrackBits(tile)) {
				case TRACK_BIT_X:
					if (pieces & ROAD_X) goto do_clear;
					roaddir = AXIS_Y;
					break;

				case TRACK_BIT_Y:
					if (pieces & ROAD_Y) goto do_clear;
					roaddir = AXIS_X;
					break;

				default: goto do_clear;
			}

			CommandCost ret = EnsureNoVehicleOnGround(tile);
			if (ret.Failed()) return ret;

			if (flags & DC_EXEC) {
				Track railtrack = AxisToTrack(OtherAxis(roaddir));
				YapfNotifyTrackLayoutChange(tile, railtrack);
				/* Update company infrastructure counts. A level crossing has two road bits. */
				Company *c = Company::GetIfValid(company);
				if (c != NULL) {
					c->infrastructure.road[rt] += 2;
					if (rt != ROADTYPE_ROAD) c->infrastructure.road[ROADTYPE_ROAD] += 2;
					DirtyCompanyInfrastructureWindows(company);
				}
				/* Update rail count for level crossings. The plain track is already
				 * counted, so only add the difference to the level crossing cost. */
				c = Company::GetIfValid(GetTileOwner(tile));
				if (c != NULL) c->infrastructure.rail[GetRailType(tile)] += LEVELCROSSING_TRACKBIT_FACTOR - 1;

				/* Always add road to the roadtypes (can't draw without it) */
				bool reserved = HasBit(GetRailReservationTrackBits(tile), railtrack);
				MakeRoadCrossing(tile, company, company, GetTileOwner(tile), roaddir, GetRailType(tile), RoadTypeToRoadTypes(rt) | ROADTYPES_ROAD, p2);
				SetCrossingReservation(tile, reserved);
				UpdateLevelCrossing(tile, false);
				MarkTileDirtyByTile(tile);
			}
			return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_ROAD] * (rt == ROADTYPE_ROAD ? 2 : 4));
		}

		case MP_STATION: {
			if ((GetAnyRoadBits(tile, rt) & pieces) == pieces) return_cmd_error(STR_ERROR_ALREADY_BUILT);
			if (!IsDriveThroughStopTile(tile)) goto do_clear;

			RoadBits curbits = AxisToRoadBits(DiagDirToAxis(GetRoadStopDir(tile)));
			if (pieces & ~curbits) goto do_clear;
			pieces = curbits; // we need to pay for both roadbits

			if (HasTileRoadType(tile, rt)) return_cmd_error(STR_ERROR_ALREADY_BUILT);
			break;
		}

		case MP_TUNNELBRIDGE: {
			if (GetTunnelBridgeTransportType(tile) != TRANSPORT_ROAD) goto do_clear;
			/* Only allow building the outern roadbit, so building long roads stops at existing bridges */
			if (MirrorRoadBits(DiagDirToRoadBits(GetTunnelBridgeDirection(tile))) != pieces) goto do_clear;
			if (HasTileRoadType(tile, rt)) return_cmd_error(STR_ERROR_ALREADY_BUILT);
			/* Don't allow adding roadtype to the bridge/tunnel when vehicles are already driving on it */
			CommandCost ret = TunnelBridgeIsFree(tile, GetOtherTunnelBridgeEnd(tile));
			if (ret.Failed()) return ret;
			break;
		}

		default: {
do_clear:;
			need_to_clear = true;
			break;
		}
	}

	if (need_to_clear) {
		CommandCost ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
		if (ret.Failed()) return ret;
		cost.AddCost(ret);
	}

	if (other_bits != pieces) {
		/* Check the foundation/slopes when adding road/tram bits */
		CommandCost ret = CheckRoadSlope(tileh, &pieces, existing, other_bits);
		/* Return an error if we need to build a foundation (ret != 0) but the
		 * current setting is turned off */
		if (ret.Failed() || (ret.GetCost() != 0 && !_settings_game.construction.build_on_slopes)) {
			return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
		}
		cost.AddCost(ret);
	}

	if (!need_to_clear) {
		if (IsTileType(tile, MP_ROAD)) {
			/* Don't put the pieces that already exist */
			pieces &= ComplementRoadBits(existing);

			/* Check if new road bits will have the same foundation as other existing road types */
			if (IsNormalRoad(tile)) {
				Slope slope = GetTileSlope(tile);
				Foundation found_new = GetRoadFoundation(slope, pieces | existing);

				/* Test if all other roadtypes can be built at that foundation */
				for (RoadType rtest = ROADTYPE_ROAD; rtest < ROADTYPE_END; rtest++) {
					if (rtest != rt) { // check only other road types
						RoadBits bits = GetRoadBits(tile, rtest);
						/* do not check if there are not road bits of given type */
						if (bits != ROAD_NONE && GetRoadFoundation(slope, bits) != found_new) {
							return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
						}
					}
				}
			}
		}

		CommandCost ret = EnsureNoVehicleOnGround(tile);
		if (ret.Failed()) return ret;

	}

	uint num_pieces = (!need_to_clear && IsTileType(tile, MP_TUNNELBRIDGE)) ?
			/* There are 2 pieces on *every* tile of the bridge or tunnel */
			2 * (GetTunnelBridgeLength(GetOtherTunnelBridgeEnd(tile), tile) + 2) :
			/* Count pieces */
			CountBits(pieces);

	cost.AddCost(num_pieces * _price[PR_BUILD_ROAD]);

	if (flags & DC_EXEC) {
		switch (GetTileType(tile)) {
			case MP_ROAD: {
				RoadTileType rtt = GetRoadTileType(tile);
				if (existing == ROAD_NONE || rtt == ROAD_TILE_CROSSING) {
					SetRoadTypes(tile, GetRoadTypes(tile) | RoadTypeToRoadTypes(rt));
					SetRoadOwner(tile, rt, company);
					if (rt == ROADTYPE_ROAD) SetTownIndex(tile, p2);
				}
				if (rtt != ROAD_TILE_CROSSING) SetRoadBits(tile, existing | pieces, rt);
				break;
			}

			case MP_TUNNELBRIDGE: {
				TileIndex other_end = GetOtherTunnelBridgeEnd(tile);

				SetRoadTypes(other_end, GetRoadTypes(other_end) | RoadTypeToRoadTypes(rt));
				SetRoadTypes(tile, GetRoadTypes(tile) | RoadTypeToRoadTypes(rt));
				SetRoadOwner(other_end, rt, company);
				SetRoadOwner(tile, rt, company);

				/* Mark tiles dirty that have been repaved */
				MarkTileDirtyByTile(other_end);
				MarkTileDirtyByTile(tile);
				if (IsBridge(tile)) {
					TileIndexDiff delta = TileOffsByDiagDir(GetTunnelBridgeDirection(tile));

					for (TileIndex t = tile + delta; t != other_end; t += delta) MarkTileDirtyByTile(t);
				}
				break;
			}

			case MP_STATION:
				assert(IsDriveThroughStopTile(tile));
				SetRoadTypes(tile, GetRoadTypes(tile) | RoadTypeToRoadTypes(rt));
				SetRoadOwner(tile, rt, company);
				break;

			default:
				MakeRoadNormal(tile, pieces, RoadTypeToRoadTypes(rt), p2, company, company);
				break;
		}

		/* Update company infrastructure count. */
		Company *c = Company::GetIfValid(GetRoadOwner(tile, rt));
		if (c != NULL) {
			if (IsTileType(tile, MP_TUNNELBRIDGE)) num_pieces *= TUNNELBRIDGE_TRACKBIT_FACTOR;
			c->infrastructure.road[rt] += num_pieces;
			DirtyCompanyInfrastructureWindows(c->index);
		}

		if (rt != ROADTYPE_TRAM && IsNormalRoadTile(tile)) {
			existing |= pieces;
			SetDisallowedRoadDirections(tile, IsStraightRoad(existing) ?
					GetDisallowedRoadDirections(tile) ^ toggle_drd : DRD_NONE);
		}

		MarkTileDirtyByTile(tile);
	}
	return cost;
}

/**
 * Checks whether a road or tram connection can be found when building a new road or tram.
 * @param tile Tile at which the road being built will end.
 * @param rt Roadtype of the road being built.
 * @param dir Direction that the road is following.
 * @return True if the next tile at dir direction is suitable for being connected directly by a second roadbit at the end of the road being built.
 */
static bool CanConnectToRoad(TileIndex tile, RoadType rt, DiagDirection dir)
{
	RoadBits bits = GetAnyRoadBits(tile + TileOffsByDiagDir(dir), rt, false);
	return (bits & DiagDirToRoadBits(ReverseDiagDir(dir))) != 0;
}

/**
 * Build a long piece of road.
 * @param start_tile start tile of drag (the building cost will appear over this tile)
 * @param flags operation to perform
 * @param p1 end tile of drag
 * @param p2 various bitstuffed elements
 * - p2 = (bit 0) - start tile starts in the 2nd half of tile (p2 & 1). Only used if bit 6 is set or if we are building a single tile
 * - p2 = (bit 1) - end tile starts in the 2nd half of tile (p2 & 2). Only used if bit 6 is set or if we are building a single tile
 * - p2 = (bit 2) - direction: 0 = along x-axis, 1 = along y-axis (p2 & 4)
 * - p2 = (bit 3 + 4) - road type
 * - p2 = (bit 5) - set road direction
 * - p2 = (bit 6) - defines two different behaviors for this command:
 *      - 0 = Build up to an obstacle. Do not build the first and last roadbits unless they can be connected to something, or if we are building a single tile
 *      - 1 = Fail if an obstacle is found. Always take into account bit 0 and 1. This behavior is used for scripts
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdBuildLongRoad(TileIndex start_tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	DisallowedRoadDirections drd = DRD_NORTHBOUND;

	if (p1 >= MapSize()) return CMD_ERROR;

	TileIndex end_tile = p1;
	RoadType rt = Extract<RoadType, 3, 2>(p2);
	if (!IsValidRoadType(rt) || !ValParamRoadType(rt)) return CMD_ERROR;

	Axis axis = Extract<Axis, 2, 1>(p2);
	/* Only drag in X or Y direction dictated by the direction variable */
	if (axis == AXIS_X && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
	if (axis == AXIS_Y && TileX(start_tile) != TileX(end_tile)) return CMD_ERROR; // y-axis

	DiagDirection dir = AxisToDiagDir(axis);

	/* Swap direction, also the half-tile drag var (bit 0 and 1) */
	if (start_tile > end_tile || (start_tile == end_tile && HasBit(p2, 0))) {
		dir = ReverseDiagDir(dir);
		p2 ^= 3;
		drd = DRD_SOUTHBOUND;
	}

	/* On the X-axis, we have to swap the initial bits, so they
	 * will be interpreted correctly in the GTTS. Furthermore
	 * when you just 'click' on one tile to build them. */
	if ((axis == AXIS_Y) == (start_tile == end_tile && HasBit(p2, 0) == HasBit(p2, 1))) drd ^= DRD_BOTH;
	/* No disallowed direction bits have to be toggled */
	if (!HasBit(p2, 5)) drd = DRD_NONE;

	CommandCost cost(EXPENSES_CONSTRUCTION);
	CommandCost last_error = CMD_ERROR;
	TileIndex tile = start_tile;
	bool had_bridge = false;
	bool had_tunnel = false;
	bool had_success = false;
	bool is_ai = HasBit(p2, 6);

	/* Start tile is the first tile clicked by the user. */
	for (;;) {
		RoadBits bits = AxisToRoadBits(axis);

		/* Determine which road parts should be built. */
		if (!is_ai && start_tile != end_tile) {
			/* Only build the first and last roadbit if they can connect to something. */
			if (tile == end_tile && !CanConnectToRoad(tile, rt, dir)) {
				bits = DiagDirToRoadBits(ReverseDiagDir(dir));
			} else if (tile == start_tile && !CanConnectToRoad(tile, rt, ReverseDiagDir(dir))) {
				bits = DiagDirToRoadBits(dir);
			}
		} else {
			/* Road parts only have to be built at the start tile or at the end tile. */
			if (tile == end_tile && !HasBit(p2, 1)) bits &= DiagDirToRoadBits(ReverseDiagDir(dir));
			if (tile == start_tile && HasBit(p2, 0)) bits &= DiagDirToRoadBits(dir);
		}

		CommandCost ret = DoCommand(tile, drd << 6 | rt << 4 | bits, 0, flags, CMD_BUILD_ROAD);
		if (ret.Failed()) {
			last_error = ret;
			if (last_error.GetErrorMessage() != STR_ERROR_ALREADY_BUILT) {
				if (is_ai) return last_error;
				break;
			}
		} else {
			had_success = true;
			/* Only pay for the upgrade on one side of the bridges and tunnels */
			if (IsTileType(tile, MP_TUNNELBRIDGE)) {
				if (IsBridge(tile)) {
					if (!had_bridge || GetTunnelBridgeDirection(tile) == dir) {
						cost.AddCost(ret);
					}
					had_bridge = true;
				} else { // IsTunnel(tile)
					if (!had_tunnel || GetTunnelBridgeDirection(tile) == dir) {
						cost.AddCost(ret);
					}
					had_tunnel = true;
				}
			} else {
				cost.AddCost(ret);
			}
		}

		if (tile == end_tile) break;

		tile += TileOffsByDiagDir(dir);
	}

	return had_success ? cost : last_error;
}

/**
 * Remove a long piece of road.
 * @param start_tile start tile of drag
 * @param flags operation to perform
 * @param p1 end tile of drag
 * @param p2 various bitstuffed elements
 * - p2 = (bit 0) - start tile starts in the 2nd half of tile (p2 & 1)
 * - p2 = (bit 1) - end tile starts in the 2nd half of tile (p2 & 2)
 * - p2 = (bit 2) - direction: 0 = along x-axis, 1 = along y-axis (p2 & 4)
 * - p2 = (bit 3 + 4) - road type
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdRemoveLongRoad(TileIndex start_tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	CommandCost cost(EXPENSES_CONSTRUCTION);

	if (p1 >= MapSize()) return CMD_ERROR;

	TileIndex end_tile = p1;
	RoadType rt = Extract<RoadType, 3, 2>(p2);
	if (!IsValidRoadType(rt)) return CMD_ERROR;

	Axis axis = Extract<Axis, 2, 1>(p2);
	/* Only drag in X or Y direction dictated by the direction variable */
	if (axis == AXIS_X && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
	if (axis == AXIS_Y && TileX(start_tile) != TileX(end_tile)) return CMD_ERROR; // y-axis

	/* Swap start and ending tile, also the half-tile drag var (bit 0 and 1) */
	if (start_tile > end_tile || (start_tile == end_tile && HasBit(p2, 0))) {
		TileIndex t = start_tile;
		start_tile = end_tile;
		end_tile = t;
		p2 ^= IsInsideMM(p2 & 3, 1, 3) ? 3 : 0;
	}

	Money money = GetAvailableMoneyForCommand();
	TileIndex tile = start_tile;
	CommandCost last_error = CMD_ERROR;
	bool had_success = false;
	/* Start tile is the small number. */
	for (;;) {
		RoadBits bits = AxisToRoadBits(axis);

		if (tile == end_tile && !HasBit(p2, 1)) bits &= ROAD_NW | ROAD_NE;
		if (tile == start_tile && HasBit(p2, 0)) bits &= ROAD_SE | ROAD_SW;

		/* try to remove the halves. */
		if (bits != 0) {
			CommandCost ret = RemoveRoad(tile, flags & ~DC_EXEC, bits, rt, true);
			if (ret.Succeeded()) {
				if (flags & DC_EXEC) {
					money -= ret.GetCost();
					if (money < 0) {
						_additional_cash_required = DoCommand(start_tile, end_tile, p2, flags & ~DC_EXEC, CMD_REMOVE_LONG_ROAD).GetCost();
						return cost;
					}
					RemoveRoad(tile, flags, bits, rt, true, false);
				}
				cost.AddCost(ret);
				had_success = true;
			} else {
				/* Ownership errors are more important. */
				if (last_error.GetErrorMessage() != STR_ERROR_OWNED_BY) last_error = ret;
			}
		}

		if (tile == end_tile) break;

		tile += (axis == AXIS_Y) ? TileDiffXY(0, 1) : TileDiffXY(1, 0);
	}

	return had_success ? cost : last_error;
}

/**
 * Build a road depot.
 * @param tile tile where to build the depot
 * @param flags operation to perform
 * @param p1 bit 0..1 entrance direction (DiagDirection)
 *           bit 2..3 road type
 * @param p2 unused
 * @param text unused
 * @return the cost of this operation or an error
 *
 * @todo When checking for the tile slope,
 * distinguish between "Flat land required" and "land sloped in wrong direction"
 */
CommandCost CmdBuildRoadDepot(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	DiagDirection dir = Extract<DiagDirection, 0, 2>(p1);
	RoadType rt = Extract<RoadType, 2, 2>(p1);

	if (!IsValidRoadType(rt) || !ValParamRoadType(rt)) return CMD_ERROR;

	Slope tileh = GetTileSlope(tile);
	if (tileh != SLOPE_FLAT && (
				!_settings_game.construction.build_on_slopes ||
				!CanBuildDepotByTileh(dir, tileh)
			)) {
		return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
	}

	CommandCost cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
	if (cost.Failed()) return cost;

	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);

	if (!Depot::CanAllocateItem()) return CMD_ERROR;

	if (flags & DC_EXEC) {
		Depot *dep = new Depot(tile);
		dep->build_date = _date;

		/* A road depot has two road bits. */
		Company::Get(_current_company)->infrastructure.road[rt] += 2;
		DirtyCompanyInfrastructureWindows(_current_company);

		MakeRoadDepot(tile, _current_company, dep->index, dir, rt);
		MarkTileDirtyByTile(tile);
		MakeDefaultName(dep);
	}
	cost.AddCost(_price[PR_BUILD_DEPOT_ROAD]);
	return cost;
}

static CommandCost RemoveRoadDepot(TileIndex tile, DoCommandFlag flags)
{
	if (_current_company != OWNER_WATER) {
		CommandCost ret = CheckTileOwnership(tile);
		if (ret.Failed()) return ret;
	}

	CommandCost ret = EnsureNoVehicleOnGround(tile);
	if (ret.Failed()) return ret;

	if (flags & DC_EXEC) {
		Company *c = Company::GetIfValid(GetTileOwner(tile));
		if (c != NULL) {
			/* A road depot has two road bits. */
			c->infrastructure.road[FIND_FIRST_BIT(GetRoadTypes(tile))] -= 2;
			DirtyCompanyInfrastructureWindows(c->index);
		}

		delete Depot::GetByTile(tile);
		DoClearSquare(tile);
	}

	return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_DEPOT_ROAD]);
}

static CommandCost ClearTile_Road(TileIndex tile, DoCommandFlag flags)
{
	switch (GetRoadTileType(tile)) {
		case ROAD_TILE_NORMAL: {
			RoadBits b = GetAllRoadBits(tile);

			/* Clear the road if only one piece is on the tile OR we are not using the DC_AUTO flag */
			if ((HasExactlyOneBit(b) && GetRoadBits(tile, ROADTYPE_TRAM) == ROAD_NONE) || !(flags & DC_AUTO)) {
				CommandCost ret(EXPENSES_CONSTRUCTION);
				RoadType rt;
				FOR_EACH_SET_ROADTYPE(rt, GetRoadTypes(tile)) {
					CommandCost tmp_ret = RemoveRoad(tile, flags, GetRoadBits(tile, rt), rt, true);
					if (tmp_ret.Failed()) return tmp_ret;
					ret.AddCost(tmp_ret);
				}
				return ret;
			}
			return_cmd_error(STR_ERROR_MUST_REMOVE_ROAD_FIRST);
		}

		case ROAD_TILE_CROSSING: {
			RoadTypes rts = GetRoadTypes(tile);
			CommandCost ret(EXPENSES_CONSTRUCTION);

			if (flags & DC_AUTO) return_cmd_error(STR_ERROR_MUST_REMOVE_ROAD_FIRST);

			/* Must iterate over the roadtypes in a reverse manner because
			 * tram tracks must be removed before the road bits. */
			RoadType rt = ROADTYPE_TRAM;
			do {
				if (HasBit(rts, rt)) {
					CommandCost tmp_ret = RemoveRoad(tile, flags, GetCrossingRoadBits(tile), rt, false);
					if (tmp_ret.Failed()) return tmp_ret;
					ret.AddCost(tmp_ret);
				}
			} while (rt-- != ROADTYPE_ROAD);

			if (flags & DC_EXEC) {
				DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
			}
			return ret;
		}

		default:
		case ROAD_TILE_DEPOT:
			if (flags & DC_AUTO) {
				return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
			}
			return RemoveRoadDepot(tile, flags);
	}
}


struct DrawRoadTileStruct {
	uint16 image;
	byte subcoord_x;
	byte subcoord_y;
};

#include "table/road_land.h"

/**
 * Get the foundationtype of a RoadBits Slope combination
 *
 * @param tileh The Slope part
 * @param bits The RoadBits part
 * @return The resulting Foundation
 */
static Foundation GetRoadFoundation(Slope tileh, RoadBits bits)
{
	/* Flat land and land without a road doesn't require a foundation */
	if (tileh == SLOPE_FLAT || bits == ROAD_NONE) return FOUNDATION_NONE;

	/* Steep slopes behave the same as slopes with one corner raised. */
	if (IsSteepSlope(tileh)) {
		tileh = SlopeWithOneCornerRaised(GetHighestSlopeCorner(tileh));
	}

	/* Leveled RoadBits on a slope */
	if ((_invalid_tileh_slopes_road[0][tileh] & bits) == ROAD_NONE) return FOUNDATION_LEVELED;

	/* Straight roads without foundation on a slope */
	if (!IsSlopeWithOneCornerRaised(tileh) &&
			(_invalid_tileh_slopes_road[1][tileh] & bits) == ROAD_NONE)
		return FOUNDATION_NONE;

	/* Roads on steep Slopes or on Slopes with one corner raised */
	return (bits == ROAD_X ? FOUNDATION_INCLINED_X : FOUNDATION_INCLINED_Y);
}

const byte _road_sloped_sprites[14] = {
	0,  0,  2,  0,
	0,  1,  0,  0,
	3,  0,  0,  0,
	0,  0
};

/**
 * Whether to draw unpaved roads regardless of the town zone.
 * By default, OpenTTD always draws roads as unpaved if they are on a desert
 * tile or above the snowline. Newgrf files, however, can set a bit that allows
 * paved roads to be built on desert tiles as they would be on grassy tiles.
 *
 * @param tile The tile the road is on
 * @param roadside What sort of road this is
 * @return True if the road should be drawn unpaved regardless of the roadside.
 */
static bool AlwaysDrawUnpavedRoads(TileIndex tile, Roadside roadside)
{
	return (IsOnSnow(tile) &&
			!(_settings_game.game_creation.landscape == LT_TROPIC && HasGrfMiscBit(GMB_DESERT_PAVED_ROADS) &&
				roadside != ROADSIDE_BARREN && roadside != ROADSIDE_GRASS && roadside != ROADSIDE_GRASS_ROAD_WORKS));
}

/**
 * Draws the catenary for the given tile
 * @param ti   information about the tile (slopes, height etc)
 * @param tram the roadbits for the tram
 */
void DrawTramCatenary(const TileInfo *ti, RoadBits tram)
{
	/* Do not draw catenary if it is invisible */
	if (IsInvisibilitySet(TO_CATENARY)) return;

	/* Don't draw the catenary under a low bridge */
	if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !IsTransparencySet(TO_CATENARY)) {
		int height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile));

		if (height <= GetTileMaxZ(ti->tile) + 1) return;
	}

	SpriteID front;
	SpriteID back;

	if (ti->tileh != SLOPE_FLAT) {
		back  = SPR_TRAMWAY_BACK_WIRES_SLOPED  + _road_sloped_sprites[ti->tileh - 1];
		front = SPR_TRAMWAY_FRONT_WIRES_SLOPED + _road_sloped_sprites[ti->tileh - 1];
	} else {
		back  = SPR_TRAMWAY_BASE + _road_backpole_sprites_1[tram];
		front = SPR_TRAMWAY_BASE + _road_frontwire_sprites_1[tram];
	}

	AddSortableSpriteToDraw(back,  PAL_NONE, ti->x, ti->y, 16, 16, TILE_HEIGHT + BB_HEIGHT_UNDER_BRIDGE, ti->z, IsTransparencySet(TO_CATENARY));
	AddSortableSpriteToDraw(front, PAL_NONE, ti->x, ti->y, 16, 16, TILE_HEIGHT + BB_HEIGHT_UNDER_BRIDGE, ti->z, IsTransparencySet(TO_CATENARY));
}

/**
 * Draws details on/around the road
 * @param img the sprite to draw
 * @param ti  the tile to draw on
 * @param dx  the offset from the top of the BB of the tile
 * @param dy  the offset from the top of the BB of the tile
 * @param h   the height of the sprite to draw
 */
static void DrawRoadDetail(SpriteID img, const TileInfo *ti, int dx, int dy, int h)
{
	int x = ti->x | dx;
	int y = ti->y | dy;
	int z = ti->z;
	if (ti->tileh != SLOPE_FLAT) z = GetSlopePixelZ(x, y);
	AddSortableSpriteToDraw(img, PAL_NONE, x, y, 2, 2, h, z);
}

/**
 * Draw ground sprite and road pieces
 * @param ti TileInfo
 */
static void DrawRoadBits(TileInfo *ti)
{
	RoadBits road = GetRoadBits(ti->tile, ROADTYPE_ROAD);
	RoadBits tram = GetRoadBits(ti->tile, ROADTYPE_TRAM);

	SpriteID image = 0;
	PaletteID pal = PAL_NONE;

	if (ti->tileh != SLOPE_FLAT) {
		DrawFoundation(ti, GetRoadFoundation(ti->tileh, road | tram));

		/* DrawFoundation() modifies ti.
		 * Default sloped sprites.. */
		if (ti->tileh != SLOPE_FLAT) image = _road_sloped_sprites[ti->tileh - 1] + SPR_ROAD_SLOPE_START;
	}

	if (image == 0) image = _road_tile_sprites_1[road != ROAD_NONE ? road : tram];

	Roadside roadside = GetRoadside(ti->tile);

	if (AlwaysDrawUnpavedRoads(ti->tile, roadside)) {
		image += 19;
	} else {
		switch (roadside) {
			case ROADSIDE_BARREN:           pal = PALETTE_TO_BARE_LAND; break;
			case ROADSIDE_GRASS:            break;
			case ROADSIDE_GRASS_ROAD_WORKS: break;
			default:                        image -= 19; break; // Paved
		}
	}

	DrawGroundSprite(image, pal);

	/* For tram we overlay the road graphics with either tram tracks only
	 * (when there is actual road beneath the trams) or with tram tracks
	 * and some dirts which hides the road graphics */
	if (tram != ROAD_NONE) {
		if (ti->tileh != SLOPE_FLAT) {
			image = _road_sloped_sprites[ti->tileh - 1] + SPR_TRAMWAY_SLOPED_OFFSET;
		} else {
			image = _road_tile_sprites_1[tram] - SPR_ROAD_Y;
		}
		image += (road == ROAD_NONE) ? SPR_TRAMWAY_TRAM : SPR_TRAMWAY_OVERLAY;
		DrawGroundSprite(image, pal);
	}

	if (road != ROAD_NONE) {
		DisallowedRoadDirections drd = GetDisallowedRoadDirections(ti->tile);
		if (drd != DRD_NONE) {
			DrawGroundSpriteAt(SPR_ONEWAY_BASE + drd - 1 + ((road == ROAD_X) ? 0 : 3), PAL_NONE, 8, 8, GetPartialPixelZ(8, 8, ti->tileh));
		}
	}

	if (HasRoadWorks(ti->tile)) {
		/* Road works */
		DrawGroundSprite((road | tram) & ROAD_X ? SPR_EXCAVATION_X : SPR_EXCAVATION_Y, PAL_NONE);
		return;
	}

	if (tram != ROAD_NONE) DrawTramCatenary(ti, tram);

	/* Return if full detail is disabled, or we are zoomed fully out. */
	if (!HasBit(_display_opt, DO_FULL_DETAIL) || _cur_dpi->zoom > ZOOM_LVL_DETAIL) return;

	/* Do not draw details (street lights, trees) under low bridge */
	if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && (roadside == ROADSIDE_TREES || roadside == ROADSIDE_STREET_LIGHTS)) {
		int height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile));
		int minz = GetTileMaxZ(ti->tile) + 2;

		if (roadside == ROADSIDE_TREES) minz++;

		if (height < minz) return;
	}

	/* If there are no road bits, return, as there is nothing left to do */
	if (HasAtMostOneBit(road)) return;

	/* Draw extra details. */
	for (const DrawRoadTileStruct *drts = _road_display_table[roadside][road | tram]; drts->image != 0; drts++) {
		DrawRoadDetail(drts->image, ti, drts->subcoord_x, drts->subcoord_y, 0x10);
	}
}

/** Tile callback function for rendering a road tile to the screen */
static void DrawTile_Road(TileInfo *ti)
{
	switch (GetRoadTileType(ti->tile)) {
		case ROAD_TILE_NORMAL:
			DrawRoadBits(ti);
			break;

		case ROAD_TILE_CROSSING: {
			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);

			PaletteID pal = PAL_NONE;
			const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));

			if (rti->UsesOverlay()) {
				Axis axis = GetCrossingRailAxis(ti->tile);
				SpriteID road = SPR_ROAD_Y + axis;

				Roadside roadside = GetRoadside(ti->tile);

				if (AlwaysDrawUnpavedRoads(ti->tile, roadside)) {
					road += 19;
				} else {
					switch (roadside) {
						case ROADSIDE_BARREN: pal = PALETTE_TO_BARE_LAND; break;
						case ROADSIDE_GRASS:  break;
						default:              road -= 19; break; // Paved
					}
				}

				DrawGroundSprite(road, pal);

				SpriteID rail = GetCustomRailSprite(rti, ti->tile, RTSG_CROSSING) + axis;
				/* Draw tracks, but draw PBS reserved tracks darker. */
				pal = (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasCrossingReservation(ti->tile)) ? PALETTE_CRASH : PAL_NONE;
				DrawGroundSprite(rail, pal);

				DrawRailTileSeq(ti, &_crossing_layout, TO_CATENARY, rail, 0, PAL_NONE);
			} else {
				SpriteID image = rti->base_sprites.crossing;

				if (GetCrossingRoadAxis(ti->tile) == AXIS_X) image++;
				if (IsCrossingBarred(ti->tile)) image += 2;

				Roadside roadside = GetRoadside(ti->tile);

				if (AlwaysDrawUnpavedRoads(ti->tile, roadside)) {
					image += 8;
				} else {
					switch (roadside) {
						case ROADSIDE_BARREN: pal = PALETTE_TO_BARE_LAND; break;
						case ROADSIDE_GRASS:  break;
						default:              image += 4; break; // Paved
					}
				}

				DrawGroundSprite(image, pal);

				/* PBS debugging, draw reserved tracks darker */
				if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasCrossingReservation(ti->tile)) {
					DrawGroundSprite(GetCrossingRoadAxis(ti->tile) == AXIS_Y ? GetRailTypeInfo(GetRailType(ti->tile))->base_sprites.single_x : GetRailTypeInfo(GetRailType(ti->tile))->base_sprites.single_y, PALETTE_CRASH);
				}
			}

			if (HasTileRoadType(ti->tile, ROADTYPE_TRAM)) {
				DrawGroundSprite(SPR_TRAMWAY_OVERLAY + (GetCrossingRoadAxis(ti->tile) ^ 1), pal);
				DrawTramCatenary(ti, GetCrossingRoadBits(ti->tile));
			}
			if (HasCatenaryDrawn(GetRailType(ti->tile))) DrawCatenary(ti);
			break;
		}

		default:
		case ROAD_TILE_DEPOT: {
			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);

			PaletteID palette = COMPANY_SPRITE_COLOUR(GetTileOwner(ti->tile));

			const DrawTileSprites *dts;
			if (HasTileRoadType(ti->tile, ROADTYPE_TRAM)) {
				dts =  &_tram_depot[GetRoadDepotDirection(ti->tile)];
			} else {
				dts =  &_road_depot[GetRoadDepotDirection(ti->tile)];
			}

			DrawGroundSprite(dts->ground.sprite, PAL_NONE);
			DrawOrigTileSeq(ti, dts, TO_BUILDINGS, palette);
			break;
		}
	}
	DrawBridgeMiddle(ti);
}

/**
 * Draw the road depot sprite.
 * @param x   The x offset to draw at.
 * @param y   The y offset to draw at.
 * @param dir The direction the depot must be facing.
 * @param rt  The road type of the depot to draw.
 */
void DrawRoadDepotSprite(int x, int y, DiagDirection dir, RoadType rt)
{
	PaletteID palette = COMPANY_SPRITE_COLOUR(_local_company);
	const DrawTileSprites *dts = (rt == ROADTYPE_TRAM) ? &_tram_depot[dir] : &_road_depot[dir];

	x += 33;
	y += 17;

	DrawSprite(dts->ground.sprite, PAL_NONE, x, y);
	DrawOrigTileSeqInGUI(x, y, dts, palette);
}

/**
 * Updates cached nearest town for all road tiles
 * @param invalidate are we just invalidating cached data?
 * @pre invalidate == true implies _generating_world == true
 */
void UpdateNearestTownForRoadTiles(bool invalidate)
{
	assert(!invalidate || _generating_world);

	for (TileIndex t = 0; t < MapSize(); t++) {
		if (IsTileType(t, MP_ROAD) && !IsRoadDepot(t) && !HasTownOwnedRoad(t)) {
			TownID tid = (TownID)INVALID_TOWN;
			if (!invalidate) {
				const Town *town = CalcClosestTownFromTile(t);
				if (town != NULL) tid = town->index;
			}
			SetTownIndex(t, tid);
		}
	}
}

static int GetSlopePixelZ_Road(TileIndex tile, uint x, uint y)
{

	if (IsNormalRoad(tile)) {
		int z;
		Slope tileh = GetTilePixelSlope(tile, &z);
		if (tileh == SLOPE_FLAT) return z;

		Foundation f = GetRoadFoundation(tileh, GetAllRoadBits(tile));
		z += ApplyPixelFoundationToSlope(f, &tileh);
		return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
	} else {
		return GetTileMaxPixelZ(tile);
	}
}

static Foundation GetFoundation_Road(TileIndex tile, Slope tileh)
{
	if (IsNormalRoad(tile)) {
		return GetRoadFoundation(tileh, GetAllRoadBits(tile));
	} else {
		return FlatteningFoundation(tileh);
	}
}

static const Roadside _town_road_types[][2] = {
	{ ROADSIDE_GRASS,         ROADSIDE_GRASS },
	{ ROADSIDE_PAVED,         ROADSIDE_PAVED },
	{ ROADSIDE_PAVED,         ROADSIDE_PAVED },
	{ ROADSIDE_TREES,         ROADSIDE_TREES },
	{ ROADSIDE_STREET_LIGHTS, ROADSIDE_PAVED }
};

static const Roadside _town_road_types_2[][2] = {
	{ ROADSIDE_GRASS,         ROADSIDE_GRASS },
	{ ROADSIDE_PAVED,         ROADSIDE_PAVED },
	{ ROADSIDE_STREET_LIGHTS, ROADSIDE_PAVED },
	{ ROADSIDE_STREET_LIGHTS, ROADSIDE_PAVED },
	{ ROADSIDE_STREET_LIGHTS, ROADSIDE_PAVED }
};


static void TileLoop_Road(TileIndex tile)
{
	switch (_settings_game.game_creation.landscape) {
		case LT_ARCTIC:
			if (IsOnSnow(tile) != (GetTileZ(tile) > GetSnowLine())) {
				ToggleSnow(tile);
				MarkTileDirtyByTile(tile);
			}
			break;

		case LT_TROPIC:
			if (GetTropicZone(tile) == TROPICZONE_DESERT && !IsOnDesert(tile)) {
				ToggleDesert(tile);
				MarkTileDirtyByTile(tile);
			}
			break;
	}

	if (IsRoadDepot(tile)) return;

	const Town *t = ClosestTownFromTile(tile, UINT_MAX);
	if (!HasRoadWorks(tile)) {
		HouseZonesBits grp = HZB_TOWN_EDGE;

		if (t != NULL) {
			grp = GetTownRadiusGroup(t, tile);

			/* Show an animation to indicate road work */
			if (t->road_build_months != 0 &&
					(DistanceManhattan(t->xy, tile) < 8 || grp != HZB_TOWN_EDGE) &&
					IsNormalRoad(tile) && !HasAtMostOneBit(GetAllRoadBits(tile))) {
				if (GetFoundationSlope(tile) == SLOPE_FLAT && EnsureNoVehicleOnGround(tile).Succeeded() && Chance16(1, 40)) {
					StartRoadWorks(tile);

					if (_settings_client.sound.ambient) SndPlayTileFx(SND_21_JACKHAMMER, tile);
					CreateEffectVehicleAbove(
						TileX(tile) * TILE_SIZE + 7,
						TileY(tile) * TILE_SIZE + 7,
						0,
						EV_BULLDOZER);
					MarkTileDirtyByTile(tile);
					return;
				}
			}
		}

		{
			/* Adjust road ground type depending on 'grp' (grp is the distance to the center) */
			const Roadside *new_rs = (_settings_game.game_creation.landscape == LT_TOYLAND) ? _town_road_types_2[grp] : _town_road_types[grp];
			Roadside cur_rs = GetRoadside(tile);

			/* We have our desired type, do nothing */
			if (cur_rs == new_rs[0]) return;

			/* We have the pre-type of the desired type, switch to the desired type */
			if (cur_rs == new_rs[1]) {
				cur_rs = new_rs[0];
			/* We have barren land, install the pre-type */
			} else if (cur_rs == ROADSIDE_BARREN) {
				cur_rs = new_rs[1];
			/* We're totally off limits, remove any installation and make barren land */
			} else {
				cur_rs = ROADSIDE_BARREN;
			}
			SetRoadside(tile, cur_rs);
			MarkTileDirtyByTile(tile);
		}
	} else if (IncreaseRoadWorksCounter(tile)) {
		TerminateRoadWorks(tile);

		if (_settings_game.economy.mod_road_rebuild) {
			/* Generate a nicer town surface */
			const RoadBits old_rb = GetAnyRoadBits(tile, ROADTYPE_ROAD);
			const RoadBits new_rb = CleanUpRoadBits(tile, old_rb);

			if (old_rb != new_rb) {
				RemoveRoad(tile, DC_EXEC | DC_AUTO | DC_NO_WATER, (old_rb ^ new_rb), ROADTYPE_ROAD, true);
			}
		}

		MarkTileDirtyByTile(tile);
	}
}

static bool ClickTile_Road(TileIndex tile)
{
	if (!IsRoadDepot(tile)) return false;

	ShowDepotWindow(tile, VEH_ROAD);
	return true;
}

/* Converts RoadBits to TrackBits */
static const TrackBits _road_trackbits[16] = {
	TRACK_BIT_NONE,                                  // ROAD_NONE
	TRACK_BIT_NONE,                                  // ROAD_NW
	TRACK_BIT_NONE,                                  // ROAD_SW
	TRACK_BIT_LEFT,                                  // ROAD_W
	TRACK_BIT_NONE,                                  // ROAD_SE
	TRACK_BIT_Y,                                     // ROAD_Y
	TRACK_BIT_LOWER,                                 // ROAD_S
	TRACK_BIT_LEFT | TRACK_BIT_LOWER | TRACK_BIT_Y,  // ROAD_Y | ROAD_SW
	TRACK_BIT_NONE,                                  // ROAD_NE
	TRACK_BIT_UPPER,                                 // ROAD_N
	TRACK_BIT_X,                                     // ROAD_X
	TRACK_BIT_LEFT | TRACK_BIT_UPPER | TRACK_BIT_X,  // ROAD_X | ROAD_NW
	TRACK_BIT_RIGHT,                                 // ROAD_E
	TRACK_BIT_RIGHT | TRACK_BIT_UPPER | TRACK_BIT_Y, // ROAD_Y | ROAD_NE
	TRACK_BIT_RIGHT | TRACK_BIT_LOWER | TRACK_BIT_X, // ROAD_X | ROAD_SE
	TRACK_BIT_ALL,                                   // ROAD_ALL
};

static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
{
	TrackdirBits trackdirbits = TRACKDIR_BIT_NONE;
	TrackdirBits red_signals = TRACKDIR_BIT_NONE; // crossing barred
	switch (mode) {
		case TRANSPORT_RAIL:
			if (IsLevelCrossing(tile)) trackdirbits = TrackBitsToTrackdirBits(GetCrossingRailBits(tile));
			break;

		case TRANSPORT_ROAD:
			if ((GetRoadTypes(tile) & sub_mode) == 0) break;
			switch (GetRoadTileType(tile)) {
				case ROAD_TILE_NORMAL: {
					const uint drd_to_multiplier[DRD_END] = { 0x101, 0x100, 0x1, 0x0 };
					RoadType rt = (RoadType)FindFirstBit(sub_mode);
					RoadBits bits = GetRoadBits(tile, rt);

					/* no roadbit at this side of tile, return 0 */
					if (side != INVALID_DIAGDIR && (DiagDirToRoadBits(side) & bits) == 0) break;

					uint multiplier = drd_to_multiplier[rt == ROADTYPE_TRAM ? DRD_NONE : GetDisallowedRoadDirections(tile)];
					if (!HasRoadWorks(tile)) trackdirbits = (TrackdirBits)(_road_trackbits[bits] * multiplier);
					break;
				}

				case ROAD_TILE_CROSSING: {
					Axis axis = GetCrossingRoadAxis(tile);

					if (side != INVALID_DIAGDIR && axis != DiagDirToAxis(side)) break;

					trackdirbits = TrackBitsToTrackdirBits(AxisToTrackBits(axis));
					if (IsCrossingBarred(tile)) red_signals = trackdirbits;
					break;
				}

				default:
				case ROAD_TILE_DEPOT: {
					DiagDirection dir = GetRoadDepotDirection(tile);

					if (side != INVALID_DIAGDIR && side != dir) break;

					trackdirbits = TrackBitsToTrackdirBits(DiagDirToDiagTrackBits(dir));
					break;
				}
			}
			break;

		default: break;
	}
	return CombineTrackStatus(trackdirbits, red_signals);
}

static const StringID _road_tile_strings[] = {
	STR_LAI_ROAD_DESCRIPTION_ROAD,
	STR_LAI_ROAD_DESCRIPTION_ROAD,
	STR_LAI_ROAD_DESCRIPTION_ROAD,
	STR_LAI_ROAD_DESCRIPTION_ROAD_WITH_STREETLIGHTS,
	STR_LAI_ROAD_DESCRIPTION_ROAD,
	STR_LAI_ROAD_DESCRIPTION_TREE_LINED_ROAD,
	STR_LAI_ROAD_DESCRIPTION_ROAD,
	STR_LAI_ROAD_DESCRIPTION_ROAD,
};

static void GetTileDesc_Road(TileIndex tile, TileDesc *td)
{
	Owner rail_owner = INVALID_OWNER;
	Owner road_owner = INVALID_OWNER;
	Owner tram_owner = INVALID_OWNER;

	switch (GetRoadTileType(tile)) {
		case ROAD_TILE_CROSSING: {
			td->str = STR_LAI_ROAD_DESCRIPTION_ROAD_RAIL_LEVEL_CROSSING;
			RoadTypes rts = GetRoadTypes(tile);
			rail_owner = GetTileOwner(tile);
			if (HasBit(rts, ROADTYPE_ROAD)) road_owner = GetRoadOwner(tile, ROADTYPE_ROAD);
			if (HasBit(rts, ROADTYPE_TRAM)) tram_owner = GetRoadOwner(tile, ROADTYPE_TRAM);

			const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(tile));
			td->rail_speed = rti->max_speed;

			break;
		}

		case ROAD_TILE_DEPOT:
			td->str = STR_LAI_ROAD_DESCRIPTION_ROAD_VEHICLE_DEPOT;
			road_owner = GetTileOwner(tile); // Tile has only one owner, roadtype does not matter
			td->build_date = Depot::GetByTile(tile)->build_date;
			break;

		default: {
			RoadTypes rts = GetRoadTypes(tile);
			td->str = (HasBit(rts, ROADTYPE_ROAD) ? _road_tile_strings[GetRoadside(tile)] : STR_LAI_ROAD_DESCRIPTION_TRAMWAY);
			if (HasBit(rts, ROADTYPE_ROAD)) road_owner = GetRoadOwner(tile, ROADTYPE_ROAD);
			if (HasBit(rts, ROADTYPE_TRAM)) tram_owner = GetRoadOwner(tile, ROADTYPE_TRAM);
			break;
		}
	}

	/* Now we have to discover, if the tile has only one owner or many:
	 *   - Find a first_owner of the tile. (Currently road or tram must be present, but this will break when the third type becomes available)
	 *   - Compare the found owner with the other owners, and test if they differ.
	 * Note: If road exists it will be the first_owner.
	 */
	Owner first_owner = (road_owner == INVALID_OWNER ? tram_owner : road_owner);
	bool mixed_owners = (tram_owner != INVALID_OWNER && tram_owner != first_owner) || (rail_owner != INVALID_OWNER && rail_owner != first_owner);

	if (mixed_owners) {
		/* Multiple owners */
		td->owner_type[0] = (rail_owner == INVALID_OWNER ? STR_NULL : STR_LAND_AREA_INFORMATION_RAIL_OWNER);
		td->owner[0] = rail_owner;
		td->owner_type[1] = (road_owner == INVALID_OWNER ? STR_NULL : STR_LAND_AREA_INFORMATION_ROAD_OWNER);
		td->owner[1] = road_owner;
		td->owner_type[2] = (tram_owner == INVALID_OWNER ? STR_NULL : STR_LAND_AREA_INFORMATION_TRAM_OWNER);
		td->owner[2] = tram_owner;
	} else {
		/* One to rule them all */
		td->owner[0] = first_owner;
	}
}

/**
 * Given the direction the road depot is pointing, this is the direction the
 * vehicle should be travelling in in order to enter the depot.
 */
static const byte _roadveh_enter_depot_dir[4] = {
	TRACKDIR_X_SW, TRACKDIR_Y_NW, TRACKDIR_X_NE, TRACKDIR_Y_SE
};

static VehicleEnterTileStatus VehicleEnter_Road(Vehicle *v, TileIndex tile, int x, int y)
{
	switch (GetRoadTileType(tile)) {
		case ROAD_TILE_DEPOT: {
			if (v->type != VEH_ROAD) break;

			RoadVehicle *rv = RoadVehicle::From(v);
			if (rv->frame == RVC_DEPOT_STOP_FRAME &&
					_roadveh_enter_depot_dir[GetRoadDepotDirection(tile)] == rv->state) {
				rv->state = RVSB_IN_DEPOT;
				rv->vehstatus |= VS_HIDDEN;
				rv->direction = ReverseDir(rv->direction);
				if (rv->Next() == NULL) VehicleEnterDepot(rv->First());
				rv->tile = tile;

				InvalidateWindowData(WC_VEHICLE_DEPOT, rv->tile);
				return VETSB_ENTERED_WORMHOLE;
			}
			break;
		}

		default: break;
	}
	return VETSB_CONTINUE;
}


static void ChangeTileOwner_Road(TileIndex tile, Owner old_owner, Owner new_owner)
{
	if (IsRoadDepot(tile)) {
		if (GetTileOwner(tile) == old_owner) {
			if (new_owner == INVALID_OWNER) {
				DoCommand(tile, 0, 0, DC_EXEC | DC_BANKRUPT, CMD_LANDSCAPE_CLEAR);
			} else {
				/* A road depot has two road bits. No need to dirty windows here, we'll redraw the whole screen anyway. */
				RoadType rt = (RoadType)FIND_FIRST_BIT(GetRoadTypes(tile));
				Company::Get(old_owner)->infrastructure.road[rt] -= 2;
				Company::Get(new_owner)->infrastructure.road[rt] += 2;

				SetTileOwner(tile, new_owner);
			}
		}
		return;
	}

	for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
		/* Update all roadtypes, no matter if they are present */
		if (GetRoadOwner(tile, rt) == old_owner) {
			if (HasTileRoadType(tile, rt)) {
				/* A level crossing has two road bits. No need to dirty windows here, we'll redraw the whole screen anyway. */
				uint num_bits = IsLevelCrossing(tile) ? 2 : CountBits(GetRoadBits(tile, rt));
				Company::Get(old_owner)->infrastructure.road[rt] -= num_bits;
				if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.road[rt] += num_bits;
			}

			SetRoadOwner(tile, rt, new_owner == INVALID_OWNER ? OWNER_NONE : new_owner);
		}
	}

	if (IsLevelCrossing(tile)) {
		if (GetTileOwner(tile) == old_owner) {
			if (new_owner == INVALID_OWNER) {
				DoCommand(tile, 0, GetCrossingRailTrack(tile), DC_EXEC | DC_BANKRUPT, CMD_REMOVE_SINGLE_RAIL);
			} else {
				/* Update infrastructure counts. No need to dirty windows here, we'll redraw the whole screen anyway. */
				Company::Get(old_owner)->infrastructure.rail[GetRailType(tile)] -= LEVELCROSSING_TRACKBIT_FACTOR;
				Company::Get(new_owner)->infrastructure.rail[GetRailType(tile)] += LEVELCROSSING_TRACKBIT_FACTOR;

				SetTileOwner(tile, new_owner);
			}
		}
	}
}

static CommandCost TerraformTile_Road(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
{
	if (_settings_game.construction.build_on_slopes && AutoslopeEnabled()) {
		switch (GetRoadTileType(tile)) {
			case ROAD_TILE_CROSSING:
				if (!IsSteepSlope(tileh_new) && (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new)) && HasBit(VALID_LEVEL_CROSSING_SLOPES, tileh_new)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
				break;

			case ROAD_TILE_DEPOT:
				if (AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, GetRoadDepotDirection(tile))) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
				break;

			case ROAD_TILE_NORMAL: {
				RoadBits bits = GetAllRoadBits(tile);
				RoadBits bits_copy = bits;
				/* Check if the slope-road_bits combination is valid at all, i.e. it is safe to call GetRoadFoundation(). */
				if (CheckRoadSlope(tileh_new, &bits_copy, ROAD_NONE, ROAD_NONE).Succeeded()) {
					/* CheckRoadSlope() sometimes changes the road_bits, if it does not agree with them. */
					if (bits == bits_copy) {
						int z_old;
						Slope tileh_old = GetTileSlope(tile, &z_old);

						/* Get the slope on top of the foundation */
						z_old += ApplyFoundationToSlope(GetRoadFoundation(tileh_old, bits), &tileh_old);
						z_new += ApplyFoundationToSlope(GetRoadFoundation(tileh_new, bits), &tileh_new);

						/* The surface slope must not be changed */
						if ((z_old == z_new) && (tileh_old == tileh_new)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
					}
				}
				break;
			}

			default: NOT_REACHED();
		}
	}

	return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
}

/** Tile callback functions for road tiles */
extern const TileTypeProcs _tile_type_road_procs = {
	DrawTile_Road,           // draw_tile_proc
	GetSlopePixelZ_Road,     // get_slope_z_proc
	ClearTile_Road,          // clear_tile_proc
	NULL,                    // add_accepted_cargo_proc
	GetTileDesc_Road,        // get_tile_desc_proc
	GetTileTrackStatus_Road, // get_tile_track_status_proc
	ClickTile_Road,          // click_tile_proc
	NULL,                    // animate_tile_proc
	TileLoop_Road,           // tile_loop_proc
	ChangeTileOwner_Road,    // change_tile_owner_proc
	NULL,                    // add_produced_cargo_proc
	VehicleEnter_Road,       // vehicle_enter_tile_proc
	GetFoundation_Road,      // get_foundation_proc
	TerraformTile_Road,      // terraform_tile_proc
};