Files @ r28396:ef195b601c72
Branch filter:

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

Peter Nelson
Fix: Pass townnameparts as parameter when testing townname based companyname. (#11685)

Length of returned string could vary and pass/fail the length check with a different
string than the final selection.
   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
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r9111:983de9c5a848
r6348:a905c3e6d8fa
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11979:a450390d0f16
r10208:ef8fcc3dc4ca
r13456:7f9200df57a3
r5584:545d748cc681
r27148:4e041ae27b9d
r8144:1432edd15267
r8213:466402e95092
r27400:742251af6ade
r10177:08bad177c706
r12218:9b04ff1ad183
r14248:a9050881acd7
r15502:00ed169c2d14
r23698:1872cc5b7dd7
r19443:7701dd8d2a52
r5584:545d748cc681
r21383:942c32fb8b0e
r21383:942c32fb8b0e
r8198:888b30c1c93b
r5584:545d748cc681
r11917:612c11f7ab47
r5584:545d748cc681
r18668:b656d614c4fd
r5584:545d748cc681
r25316:59902ba5b847
r5584:545d748cc681
r5584:545d748cc681
r25316:59902ba5b847
r5584:545d748cc681
r5584:545d748cc681
r8198:888b30c1c93b
r5584:545d748cc681
r11917:612c11f7ab47
r5584:545d748cc681
r25316:59902ba5b847
r25316:59902ba5b847
r25316:59902ba5b847
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11917:612c11f7ab47
r15753:7a5fae91288a
r5584:545d748cc681
r23607:36c15679007d
r27119:18b3e09ea8be
r5584:545d748cc681
r15753:7a5fae91288a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11917:612c11f7ab47
r15753:7a5fae91288a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12292:c3b6baef441a
r12291:690f4158878e
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15175:66e0817dc450
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
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
r11976:ae6aa97461b7
r5584:545d748cc681
r10177:08bad177c706
r23607:36c15679007d
r6912:8b1a63da4658
r14849:27386629fac1
r27737:728d55b97775
r5584:545d748cc681
r11977:bc3933e2c9d0
r5584:545d748cc681
r5584:545d748cc681
r20667:47a3e7edbb11
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r20667:47a3e7edbb11
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r20667:47a3e7edbb11
r5584:545d748cc681
r5584:545d748cc681
r6348:a905c3e6d8fa
r20667:47a3e7edbb11
r5584:545d748cc681
r5584:545d748cc681
r20667:47a3e7edbb11
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
r5584:545d748cc681
r15792:8ffc6b095d0f
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
r6020:672428988b97
r6020:672428988b97
r6020:672428988b97
r6020:672428988b97
r6020:672428988b97
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6604:dbbb1b0a91d4
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6348:a905c3e6d8fa
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r23838:bfeaabaa7b1d
r5584:545d748cc681
r6020:672428988b97
r6020:672428988b97
r6020:672428988b97
r6020:672428988b97
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15175:66e0817dc450
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
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11976:ae6aa97461b7
r5584:545d748cc681
r11977:bc3933e2c9d0
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8836:911846a8cfa6
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8836:911846a8cfa6
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8836:911846a8cfa6
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r20667:47a3e7edbb11
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6348:a905c3e6d8fa
r8836:911846a8cfa6
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r27737:728d55b97775
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r27737:728d55b97775
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r27737:728d55b97775
r23607:36c15679007d
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r23607:36c15679007d
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r23607:36c15679007d
r19736:e9409fb52532
r23607:36c15679007d
r19736:e9409fb52532
r19736:e9409fb52532
r23607:36c15679007d
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19737:d7c69e3b4bd4
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r18023:2bce2aecd4c8
r18023:2bce2aecd4c8
r18023:2bce2aecd4c8
r18023:2bce2aecd4c8
r18023:2bce2aecd4c8
r18023:2bce2aecd4c8
r23607:36c15679007d
r18023:2bce2aecd4c8
r18023:2bce2aecd4c8
r18023:2bce2aecd4c8
r6516:0c4e03193684
r6516:0c4e03193684
r6516:0c4e03193684
r23607:36c15679007d
r23607:36c15679007d
r23607:36c15679007d
r16778:660bd976d69f
r16778:660bd976d69f
r6516:0c4e03193684
r15911:1490b8bf091a
r6516:0c4e03193684
r6516:0c4e03193684
r18023:2bce2aecd4c8
r6516:0c4e03193684
r6516:0c4e03193684
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r27737:728d55b97775
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r23607:36c15679007d
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r6516:0c4e03193684
r27737:728d55b97775
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11381:50206b5a9a95
r18229:a35410711978
r11381:50206b5a9a95
r6348:a905c3e6d8fa
r16365:c064d7a3acb5
r16364:0d83a8ef6993
r16365:c064d7a3acb5
r11263:dfe9dcd54165
r16364:0d83a8ef6993
r11263:dfe9dcd54165
r6348:a905c3e6d8fa
r16365:c064d7a3acb5
r16364:0d83a8ef6993
r16365:c064d7a3acb5
r11263:dfe9dcd54165
r16364:0d83a8ef6993
r5584:545d748cc681
r18644:eb1698f4ed51
r16365:c064d7a3acb5
r28021:94f16add0daf
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r5584:545d748cc681
r28021:94f16add0daf
r12109:90df01928018
r11263:dfe9dcd54165
r11263:dfe9dcd54165
r19097:ec2b0cea1565
r11263:dfe9dcd54165
r12405:ba094e765533
r18668:b656d614c4fd
r5584:545d748cc681
r5584:545d748cc681
r11263:dfe9dcd54165
r28021:94f16add0daf
r28021:94f16add0daf
r28021:94f16add0daf
r5584:545d748cc681
r11263:dfe9dcd54165
r28021:94f16add0daf
r28021:94f16add0daf
r11263:dfe9dcd54165
r19097:ec2b0cea1565
r5584:545d748cc681
r11263:dfe9dcd54165
r5584:545d748cc681
r11038:e2a95359708a
r11263:dfe9dcd54165
r28021:94f16add0daf
r28021:94f16add0daf
r28021:94f16add0daf
r11038:e2a95359708a
r18644:eb1698f4ed51
r18644:eb1698f4ed51
r18644:eb1698f4ed51
r16365:c064d7a3acb5
r6822:03c27b6969e3
r18644:eb1698f4ed51
r18644:eb1698f4ed51
r18644:eb1698f4ed51
r18644:eb1698f4ed51
r21921:87dfa96c4980
r21921:87dfa96c4980
r21921:87dfa96c4980
r21921:87dfa96c4980
r21921:87dfa96c4980
r23607:36c15679007d
r21921:87dfa96c4980
r21921:87dfa96c4980
r21008:be2e3d3c935b
r27737:728d55b97775
r23607:36c15679007d
r18644:eb1698f4ed51
r18644:eb1698f4ed51
r18644:eb1698f4ed51
r5584:545d748cc681
r10207:a1fc2f2a33db
r16365:c064d7a3acb5
r18023:2bce2aecd4c8
r16365:c064d7a3acb5
r11263:dfe9dcd54165
r16364:0d83a8ef6993
r5584:545d748cc681
r6348:a905c3e6d8fa
r18111:ddb48f8dea5e
r5584:545d748cc681
r5584:545d748cc681
r7492:75510449064b
r26753:ca3f298cd85a
r27737:728d55b97775
r10177:08bad177c706
r10177:08bad177c706
r12109:90df01928018
r5584:545d748cc681
r23607:36c15679007d
r14849:27386629fac1
r5584:545d748cc681
r5584:545d748cc681
r27272:bb139906001a
r5584:545d748cc681
r5584:545d748cc681
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r16773:b3301f1d5bbb
r6589:c803f583a91d
r7497:84fb92567fc7
r7492:75510449064b
r23607:36c15679007d
r23607:36c15679007d
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r6589:c803f583a91d
r6348:a905c3e6d8fa
r5584:545d748cc681
r5584:545d748cc681
r6348:a905c3e6d8fa
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r12405:ba094e765533
r5584:545d748cc681
r21921:87dfa96c4980
r21921:87dfa96c4980
r21921:87dfa96c4980
r21921:87dfa96c4980
r21921:87dfa96c4980
r21921:87dfa96c4980
r5584:545d748cc681
r5584:545d748cc681
r18228:6cd8bae37157
r28112:bca7556a6bb6
r5584:545d748cc681
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r27896:3f48fccebe5f
r24636:d54ea7ad5a2c
r24636:d54ea7ad5a2c
r24636:d54ea7ad5a2c
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r24636:d54ea7ad5a2c
r24636:d54ea7ad5a2c
r24636:d54ea7ad5a2c
r24636:d54ea7ad5a2c
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r15502:00ed169c2d14
r18222:d6918cba9adc
r28112:bca7556a6bb6
r18222:d6918cba9adc
r19335:74247eaadfef
r19335:74247eaadfef
r19335:74247eaadfef
r19335:74247eaadfef
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r21074:afd3cbf5c9c8
r5584:545d748cc681
r19944:25a78576fb5e
r18229:a35410711978
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r23607:36c15679007d
r18228:6cd8bae37157
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r18158:b701f552849a
r21207:331b81078315
r21207:331b81078315
r21207:331b81078315
r21207:331b81078315
r18158:b701f552849a
r18158:b701f552849a
r21008:be2e3d3c935b
r21836:1bf21d1ef6f1
r21836:1bf21d1ef6f1
r27737:728d55b97775
r23607:36c15679007d
r18158:b701f552849a
r19596:02aa696edbd2
r19596:02aa696edbd2
r19596:02aa696edbd2
r19596:02aa696edbd2
r19596:02aa696edbd2
r19596:02aa696edbd2
r18158:b701f552849a
r21207:331b81078315
r21207:331b81078315
r18158:b701f552849a
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r27737:728d55b97775
r23607:36c15679007d
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r27737:728d55b97775
r27737:728d55b97775
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r18159:2c94e9268b2c
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r24635:c539e338e87f
r6176:e229e61b4324
r6176:e229e61b4324
r27737:728d55b97775
r6176:e229e61b4324
r8665:a80565b4b6d7
r12109:90df01928018
r15813:7e34c60f1a6d
r15813:7e34c60f1a6d
r8665:a80565b4b6d7
r15813:7e34c60f1a6d
r15511:3192e165e164
r8666:a02ccc4ff4e1
r15511:3192e165e164
r15511:3192e165e164
r11981:3840cc07cbe4
r8665:a80565b4b6d7
r21335:b614378f1395
r7931:4c17a74c399e
r6176:e229e61b4324
r6176:e229e61b4324
r6176:e229e61b4324
r5584:545d748cc681
r5584:545d748cc681
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r5584:545d748cc681
r12191:a4134ef0250a
r5584:545d748cc681
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r5584:545d748cc681
r5584:545d748cc681
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r12189:24885a3e6cdf
r12189:24885a3e6cdf
r10544:3093e218ea50
r17184:a6dd7165a9b8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r14368:c681dc336057
r27884:803962be0328
r27884:803962be0328
r20037:2761c8d9b8cc
r20037:2761c8d9b8cc
r5584:545d748cc681
r5584:545d748cc681
r16089:e4ceb7ddf35b
r16089:e4ceb7ddf35b
r16369:b31b2430ee54
r16369:b31b2430ee54
r16369:b31b2430ee54
r16369:b31b2430ee54
r16369:b31b2430ee54
r16369:b31b2430ee54
r16369:b31b2430ee54
r16373:fab42163de3d
r16369:b31b2430ee54
r16369:b31b2430ee54
r16089:e4ceb7ddf35b
r16089:e4ceb7ddf35b
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r26039:cd04ecb0e841
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r18889:3231d4b64819
r18889:3231d4b64819
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r5584:545d748cc681
r5584:545d748cc681
r16089:e4ceb7ddf35b
r16089:e4ceb7ddf35b
r5584:545d748cc681
r5584:545d748cc681
r24747:8a33e9b180a8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r27271:e0993573a0ba
r27271:e0993573a0ba
r27882:e0b47acdb939
r27717:8f7c1d75f921
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r28112:bca7556a6bb6
r5584:545d748cc681
r18228:6cd8bae37157
r18228:6cd8bae37157
r9059:e1b96bee5e99
r9059:e1b96bee5e99
r12109:90df01928018
r9059:e1b96bee5e99
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r23607:36c15679007d
r24747:8a33e9b180a8
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r27271:e0993573a0ba
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r5584:545d748cc681
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r5584:545d748cc681
r5584:545d748cc681
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r24747:8a33e9b180a8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11980:193f7a6b6e37
r12109:90df01928018
r5584:545d748cc681
r11981:3840cc07cbe4
r11981:3840cc07cbe4
r18385:4404316f59b4
r16775:3ed9b708bc5a
r16775:3ed9b708bc5a
r16775:3ed9b708bc5a
r16775:3ed9b708bc5a
r11980:193f7a6b6e37
r11980:193f7a6b6e37
r5584:545d748cc681
r5584:545d748cc681
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r11979:a450390d0f16
r12109:90df01928018
r5584:545d748cc681
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r11979:a450390d0f16
r5584:545d748cc681
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r19443:7701dd8d2a52
r19443:7701dd8d2a52
r19443:7701dd8d2a52
r19443:7701dd8d2a52
r19443:7701dd8d2a52
r19443:7701dd8d2a52
r19443:7701dd8d2a52
r19443:7701dd8d2a52
r11976:ae6aa97461b7
r12109:90df01928018
r5584:545d748cc681
r11976:ae6aa97461b7
r11977:bc3933e2c9d0
r11976:ae6aa97461b7
r5584:545d748cc681
r15608:7b580ec7448a
r15608:7b580ec7448a
r6621:c0fe19bbb51d
r6621:c0fe19bbb51d
r5584:545d748cc681
r5584:545d748cc681
r25655:1030dcb7eb52
r5584:545d748cc681
r5584:545d748cc681
r5587:034e5e185dc2
r5584:545d748cc681
r5584:545d748cc681
r27942:f7389062d120
r18158:b701f552849a
r23607:36c15679007d
r18158:b701f552849a
r18158:b701f552849a
r23607:36c15679007d
r18158:b701f552849a
r18158:b701f552849a
r19736:e9409fb52532
r18158:b701f552849a
r27421:e8c2cdc1e8e6
r18158:b701f552849a
r21921:87dfa96c4980
r18158:b701f552849a
r18158:b701f552849a
r18158:b701f552849a
r18158:b701f552849a
r19736:e9409fb52532
r28112:bca7556a6bb6
r28112:bca7556a6bb6
r27884:803962be0328
r27884:803962be0328
r28112:bca7556a6bb6
r26687:39a66c00d4a4
r26687:39a66c00d4a4
r18158:b701f552849a
r18158:b701f552849a
r18158:b701f552849a
r18158:b701f552849a
r18158:b701f552849a
r18158:b701f552849a
r18158:b701f552849a
r18158:b701f552849a
r19736:e9409fb52532
r18158:b701f552849a
r18158:b701f552849a
r5584:545d748cc681
r19736:e9409fb52532
r5584:545d748cc681
r19736:e9409fb52532
r5584:545d748cc681
r23607:36c15679007d
r25353:18f8979adb60
r25353:18f8979adb60
r23607:36c15679007d
r8599:42c534166459
r5584:545d748cc681
r8836:911846a8cfa6
r5584:545d748cc681
r25353:18f8979adb60
r5584:545d748cc681
r23607:36c15679007d
r15530:e48a7b64c8a5
r27737:728d55b97775
r24597:afde5721a3b6
r5584:545d748cc681
r11985:d8202dea2203
r5584:545d748cc681
r5584:545d748cc681
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r27737:728d55b97775
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r24069:49625df81342
r19738:837a139219f0
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r19736:e9409fb52532
r23607:36c15679007d
r19736:e9409fb52532
r19736:e9409fb52532
r19738:837a139219f0
r19738:837a139219f0
r19738:837a139219f0
r19738:837a139219f0
r21299:8973364c4b52
r26039:cd04ecb0e841
r19738:837a139219f0
r19738:837a139219f0
r19738:837a139219f0
r19738:837a139219f0
r26039:cd04ecb0e841
r27737:728d55b97775
r19736:e9409fb52532
r26039:cd04ecb0e841
r26039:cd04ecb0e841
r26039:cd04ecb0e841
r19736:e9409fb52532
r19736:e9409fb52532
r21299:8973364c4b52
r21299:8973364c4b52
r21299:8973364c4b52
r23607:36c15679007d
r21299:8973364c4b52
r5584:545d748cc681
r16778:660bd976d69f
r7863:3a36f25b3b69
r7863:3a36f25b3b69
r21299:8973364c4b52
r21299:8973364c4b52
r16778:660bd976d69f
r21299:8973364c4b52
r16778:660bd976d69f
r21299:8973364c4b52
r21299:8973364c4b52
r23607:36c15679007d
r21299:8973364c4b52
r23607:36c15679007d
r21299:8973364c4b52
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r21299:8973364c4b52
r9070:e059c65164f3
r5584:545d748cc681
r5584:545d748cc681
r22459:c1921e75ce89
r5584:545d748cc681
r22461:8bf6c5210cf7
r22459:c1921e75ce89
r22459:c1921e75ce89
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r27737:728d55b97775
r23607:36c15679007d
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r26038:ced62dd5d288
r5584:545d748cc681
r11917:612c11f7ab47
r5584:545d748cc681
r5584:545d748cc681
r9436:8c85322a3b2a
r9070:e059c65164f3
r5584:545d748cc681
r26039:cd04ecb0e841
r26039:cd04ecb0e841
r26039:cd04ecb0e841
r26039:cd04ecb0e841
r26039:cd04ecb0e841
r26039:cd04ecb0e841
r22459:c1921e75ce89
r26039:cd04ecb0e841
r22459:c1921e75ce89
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r27737:728d55b97775
r23607:36c15679007d
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r22461:8bf6c5210cf7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10647:62911ec68e89
r5584:545d748cc681
r6259:e2dba394134b
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r19944:25a78576fb5e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r23838:bfeaabaa7b1d
r5584:545d748cc681
r5584:545d748cc681
r27737:728d55b97775
r5584:545d748cc681
r21299:8973364c4b52
r21299:8973364c4b52
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r19944:25a78576fb5e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r27737:728d55b97775
r5584:545d748cc681
r21299:8973364c4b52
r19736:e9409fb52532
r21299:8973364c4b52
r5584:545d748cc681
r5584:545d748cc681
r6490:ba88f1f6bfd1
r6517:6357a0cb600e
r25889:095192372b19
r6490:ba88f1f6bfd1
r25889:095192372b19
r6490:ba88f1f6bfd1
r6490:ba88f1f6bfd1
r6490:ba88f1f6bfd1
r25889:095192372b19
r6517:6357a0cb600e
r27737:728d55b97775
r25889:095192372b19
r25889:095192372b19
r25889:095192372b19
r27737:728d55b97775
r25889:095192372b19
r25889:095192372b19
r25889:095192372b19
r25889:095192372b19
r6517:6357a0cb600e
r6517:6357a0cb600e
r6517:6357a0cb600e
r6517:6357a0cb600e
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r28209:28b839eace1a
r6517:6357a0cb600e
r27232:c3562fd44d8b
r5584:545d748cc681
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r21299:8973364c4b52
r22707:80b972b362a5
r22707:80b972b362a5
r5584:545d748cc681
r21299:8973364c4b52
r23607:36c15679007d
r5584:545d748cc681
r22707:80b972b362a5
r22707:80b972b362a5
r22707:80b972b362a5
r22707:80b972b362a5
r27232:c3562fd44d8b
r27737:728d55b97775
r17834:447b5cb3ee1a
r17834:447b5cb3ee1a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11363:6906c490a00e
r11363:6906c490a00e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7550:29d560c0d2ef
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r23607:36c15679007d
r5584:545d748cc681
r7803:21a2033d0bf7
r7803:21a2033d0bf7
r7803:21a2033d0bf7
r7803:21a2033d0bf7
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6348:a905c3e6d8fa
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r12068:a96f28ffc328
r5584:545d748cc681
r12068:a96f28ffc328
r5584:545d748cc681
r5584:545d748cc681
r19404:b33cb27be7af
r5584:545d748cc681
r9070:e059c65164f3
r9070:e059c65164f3
r19404:b33cb27be7af
r9070:e059c65164f3
r9070:e059c65164f3
r23538:8df50944b27a
r9070:e059c65164f3
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r5584:545d748cc681
r9070:e059c65164f3
r23532:dc91fcd293f5
r9070:e059c65164f3
r5584:545d748cc681
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r23616:e1fb1b190a7f
r19404:b33cb27be7af
r23616:e1fb1b190a7f
r23616:e1fb1b190a7f
r19404:b33cb27be7af
r19404:b33cb27be7af
r23616:e1fb1b190a7f
r19404:b33cb27be7af
r19404:b33cb27be7af
r23616:e1fb1b190a7f
r19404:b33cb27be7af
r19404:b33cb27be7af
r23616:e1fb1b190a7f
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r9672:31eaac85a9e4
r9070:e059c65164f3
r19404:b33cb27be7af
r23538:8df50944b27a
r23959:3272bfac7f4a
r23532:dc91fcd293f5
r19404:b33cb27be7af
r23616:e1fb1b190a7f
r9070:e059c65164f3
r19944:25a78576fb5e
r23536:ce42deb0b32d
r23536:ce42deb0b32d
r23536:ce42deb0b32d
r9070:e059c65164f3
r23530:3c94d05f840c
r19404:b33cb27be7af
r5584:545d748cc681
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r23534:ced2648be38e
r23534:ced2648be38e
r9070:e059c65164f3
r19404:b33cb27be7af
r19404:b33cb27be7af
r9070:e059c65164f3
r23536:ce42deb0b32d
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r19404:b33cb27be7af
r9070:e059c65164f3
r5584:545d748cc681
r5584:545d748cc681
r19404:b33cb27be7af
r19404:b33cb27be7af
r23536:ce42deb0b32d
r23536:ce42deb0b32d
r23536:ce42deb0b32d
r19404:b33cb27be7af
r19413:8c9c14ca0ed6
r19413:8c9c14ca0ed6
r23522:1fb564b1efa6
r23522:1fb564b1efa6
r5584:545d748cc681
r15071:e236d80508bb
r15071:e236d80508bb
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r21299:8973364c4b52
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r21074:afd3cbf5c9c8
r16598:47c843cc97fe
r24521:57ec498b9221
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r19740:cdfba1e51313
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
r16598:47c843cc97fe
/*
 * 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 newgrf_engine.cpp NewGRF handling of engines. */

#include "stdafx.h"
#include "debug.h"
#include "train.h"
#include "roadveh.h"
#include "company_func.h"
#include "newgrf_cargo.h"
#include "newgrf_spritegroup.h"
#include "timer/timer_game_calendar.h"
#include "vehicle_func.h"
#include "core/random_func.hpp"
#include "core/container_func.hpp"
#include "aircraft.h"
#include "station_base.h"
#include "company_base.h"
#include "newgrf_railtype.h"
#include "newgrf_roadtype.h"
#include "ship.h"

#include "safeguards.h"

void SetWagonOverrideSprites(EngineID engine, CargoID cargo, const SpriteGroup *group, EngineID *train_id, uint trains)
{
	Engine *e = Engine::Get(engine);

	assert(cargo < NUM_CARGO + 2); // Include CT_DEFAULT and CT_PURCHASE pseudo cargoes.

	WagonOverride *wo = &e->overrides.emplace_back();
	wo->group = group;
	wo->cargo = cargo;
	wo->engines.assign(train_id, train_id + trains);
}

const SpriteGroup *GetWagonOverrideSpriteSet(EngineID engine, CargoID cargo, EngineID overriding_engine)
{
	const Engine *e = Engine::Get(engine);

	for (const WagonOverride &wo : e->overrides) {
		if (wo.cargo != cargo && wo.cargo != CT_DEFAULT) continue;
		if (std::find(wo.engines.begin(), wo.engines.end(), overriding_engine) != wo.engines.end()) return wo.group;
	}
	return nullptr;
}

void SetCustomEngineSprites(EngineID engine, byte cargo, const SpriteGroup *group)
{
	Engine *e = Engine::Get(engine);
	assert(cargo < lengthof(e->grf_prop.spritegroup));

	if (e->grf_prop.spritegroup[cargo] != nullptr) {
		GrfMsg(6, "SetCustomEngineSprites: engine {} cargo {} already has group -- replacing", engine, cargo);
	}
	e->grf_prop.spritegroup[cargo] = group;
}


/**
 * Tie a GRFFile entry to an engine, to allow us to retrieve GRF parameters
 * etc during a game.
 * @param engine Engine ID to tie the GRFFile to.
 * @param file   Pointer of GRFFile to tie.
 */
void SetEngineGRF(EngineID engine, const GRFFile *file)
{
	Engine *e = Engine::Get(engine);
	e->grf_prop.grffile = file;
}


static int MapOldSubType(const Vehicle *v)
{
	switch (v->type) {
		case VEH_TRAIN:
			if (Train::From(v)->IsEngine()) return 0;
			if (Train::From(v)->IsFreeWagon()) return 4;
			return 2;
		case VEH_ROAD:
		case VEH_SHIP:     return 0;
		case VEH_AIRCRAFT:
		case VEH_DISASTER: return v->subtype;
		case VEH_EFFECT:   return v->subtype << 1;
		default: NOT_REACHED();
	}
}


/* TTDP style aircraft movement states for GRF Action 2 Var 0xE2 */
enum TTDPAircraftMovementStates {
	AMS_TTDP_HANGAR,
	AMS_TTDP_TO_HANGAR,
	AMS_TTDP_TO_PAD1,
	AMS_TTDP_TO_PAD2,
	AMS_TTDP_TO_PAD3,
	AMS_TTDP_TO_ENTRY_2_AND_3,
	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,
	AMS_TTDP_TO_JUNCTION,
	AMS_TTDP_LEAVE_RUNWAY,
	AMS_TTDP_TO_INWAY,
	AMS_TTDP_TO_RUNWAY,
	AMS_TTDP_TO_OUTWAY,
	AMS_TTDP_WAITING,
	AMS_TTDP_TAKEOFF,
	AMS_TTDP_TO_TAKEOFF,
	AMS_TTDP_CLIMBING,
	AMS_TTDP_FLIGHT_APPROACH,
	AMS_TTDP_UNUSED_0x11,
	AMS_TTDP_FLIGHT_TO_TOWER,
	AMS_TTDP_UNUSED_0x13,
	AMS_TTDP_FLIGHT_FINAL,
	AMS_TTDP_FLIGHT_DESCENT,
	AMS_TTDP_BRAKING,
	AMS_TTDP_HELI_TAKEOFF_AIRPORT,
	AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,
	AMS_TTDP_HELI_LAND_AIRPORT,
	AMS_TTDP_HELI_TAKEOFF_HELIPORT,
	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,
	AMS_TTDP_HELI_LAND_HELIPORT,
};


/**
 * Map OTTD aircraft movement states to TTDPatch style movement states
 * (VarAction 2 Variable 0xE2)
 */
static byte MapAircraftMovementState(const Aircraft *v)
{
	const Station *st = GetTargetAirportIfValid(v);
	if (st == nullptr) return AMS_TTDP_FLIGHT_TO_TOWER;

	const AirportFTAClass *afc = st->airport.GetFTA();
	uint16_t amdflag = afc->MovingData(v->pos)->flag;

	switch (v->state) {
		case HANGAR:
			/* The international airport is a special case as helicopters can land in
			 * front of the hangar. Helicopters also change their air.state to
			 * AMED_HELI_LOWER some time before actually descending. */

			/* This condition only occurs for helicopters, during descent,
			 * to a landing by the hangar of an international airport. */
			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPORT;

			/* This condition only occurs for helicopters, before starting descent,
			 * to a landing by the hangar of an international airport. */
			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

			/* The final two conditions apply to helicopters or aircraft.
			 * Has reached hangar? */
			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGAR;

			/* Still moving towards hangar. */
			return AMS_TTDP_TO_HANGAR;

		case TERM1:
			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;
			return AMS_TTDP_TO_JUNCTION;

		case TERM2:
			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;
			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

		case TERM3:
		case TERM4:
		case TERM5:
		case TERM6:
		case TERM7:
		case TERM8:
			/* TTDPatch only has 3 terminals, so treat these states the same */
			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;
			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

		case HELIPAD1:
		case HELIPAD2:
		case HELIPAD3:
			/* Will only occur for helicopters.*/
			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPORT; // Descending.
			if (amdflag & AMED_SLOWTURN)   return AMS_TTDP_FLIGHT_TO_TOWER;   // Still hasn't started descent.
			return AMS_TTDP_TO_JUNCTION; // On the ground.

		case TAKEOFF: // Moving to takeoff position.
			return AMS_TTDP_TO_OUTWAY;

		case STARTTAKEOFF: // Accelerating down runway.
			return AMS_TTDP_TAKEOFF;

		case ENDTAKEOFF: // Ascent
			return AMS_TTDP_CLIMBING;

		case HELITAKEOFF: // Helicopter is moving to take off position.
			if (afc->delta_z == 0) {
				return amdflag & AMED_HELI_RAISE ?
					AMS_TTDP_HELI_TAKEOFF_AIRPORT : AMS_TTDP_TO_JUNCTION;
			} else {
				return AMS_TTDP_HELI_TAKEOFF_HELIPORT;
			}

		case FLYING:
			return amdflag & AMED_HOLD ? AMS_TTDP_FLIGHT_APPROACH : AMS_TTDP_FLIGHT_TO_TOWER;

		case LANDING: // Descent
			return AMS_TTDP_FLIGHT_DESCENT;

		case ENDLANDING: // On the runway braking
			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;
			/* Landed - moving off runway */
			return AMS_TTDP_TO_INWAY;

		case HELILANDING:
		case HELIENDLANDING: // Helicoptor is descending.
			if (amdflag & AMED_HELI_LOWER) {
				return afc->delta_z == 0 ?
					AMS_TTDP_HELI_LAND_AIRPORT : AMS_TTDP_HELI_LAND_HELIPORT;
			} else {
				return AMS_TTDP_FLIGHT_TO_TOWER;
			}

		default:
			return AMS_TTDP_HANGAR;
	}
}


/* TTDP style aircraft movement action for GRF Action 2 Var 0xE6 */
enum TTDPAircraftMovementActions {
	AMA_TTDP_IN_HANGAR,
	AMA_TTDP_ON_PAD1,
	AMA_TTDP_ON_PAD2,
	AMA_TTDP_ON_PAD3,
	AMA_TTDP_HANGAR_TO_PAD1,
	AMA_TTDP_HANGAR_TO_PAD2,
	AMA_TTDP_HANGAR_TO_PAD3,
	AMA_TTDP_LANDING_TO_PAD1,
	AMA_TTDP_LANDING_TO_PAD2,
	AMA_TTDP_LANDING_TO_PAD3,
	AMA_TTDP_PAD1_TO_HANGAR,
	AMA_TTDP_PAD2_TO_HANGAR,
	AMA_TTDP_PAD3_TO_HANGAR,
	AMA_TTDP_PAD1_TO_TAKEOFF,
	AMA_TTDP_PAD2_TO_TAKEOFF,
	AMA_TTDP_PAD3_TO_TAKEOFF,
	AMA_TTDP_HANGAR_TO_TAKOFF,
	AMA_TTDP_LANDING_TO_HANGAR,
	AMA_TTDP_IN_FLIGHT,
};


/**
 * Map OTTD aircraft movement states to TTDPatch style movement actions
 * (VarAction 2 Variable 0xE6)
 * This is not fully supported yet but it's enough for Planeset.
 */
static byte MapAircraftMovementAction(const Aircraft *v)
{
	switch (v->state) {
		case HANGAR:
			return (v->cur_speed > 0) ? AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_IN_HANGAR;

		case TERM1:
		case HELIPAD1:
			return (v->current_order.IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD1 : AMA_TTDP_LANDING_TO_PAD1;

		case TERM2:
		case HELIPAD2:
			return (v->current_order.IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD2 : AMA_TTDP_LANDING_TO_PAD2;

		case TERM3:
		case TERM4:
		case TERM5:
		case TERM6:
		case TERM7:
		case TERM8:
		case HELIPAD3:
			return (v->current_order.IsType(OT_LOADING)) ? AMA_TTDP_ON_PAD3 : AMA_TTDP_LANDING_TO_PAD3;

		case TAKEOFF:      // Moving to takeoff position
		case STARTTAKEOFF: // Accelerating down runway
		case ENDTAKEOFF:   // Ascent
		case HELITAKEOFF:
			/* @todo Need to find which terminal (or hangar) we've come from. How? */
			return AMA_TTDP_PAD1_TO_TAKEOFF;

		case FLYING:
			return AMA_TTDP_IN_FLIGHT;

		case LANDING:    // Descent
		case ENDLANDING: // On the runway braking
		case HELILANDING:
		case HELIENDLANDING:
			/* @todo Need to check terminal we're landing to. Is it known yet? */
			return (v->current_order.IsType(OT_GOTO_DEPOT)) ?
				AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;

		default:
			return AMA_TTDP_IN_HANGAR;
	}
}


/* virtual */ uint32_t VehicleScopeResolver::GetRandomBits() const
{
	return this->v == nullptr ? 0 : this->v->random_bits;
}

/* virtual */ uint32_t VehicleScopeResolver::GetTriggers() const
{
	return this->v == nullptr ? 0 : this->v->waiting_triggers;
}


/* virtual */ ScopeResolver *VehicleResolverObject::GetScope(VarSpriteGroupScope scope, byte relative)
{
	switch (scope) {
		case VSG_SCOPE_SELF:   return &this->self_scope;
		case VSG_SCOPE_PARENT: return &this->parent_scope;
		case VSG_SCOPE_RELATIVE: {
			int32_t count = GB(relative, 0, 4);
			if (this->self_scope.v != nullptr && (relative != this->cached_relative_count || count == 0)) {
				/* Note: This caching only works as long as the VSG_SCOPE_RELATIVE cannot be used in
				 *       VarAct2 with procedure calls. */
				if (count == 0) count = GetRegister(0x100);

				const Vehicle *v = nullptr;
				switch (GB(relative, 6, 2)) {
					default: NOT_REACHED();
					case 0x00: // count back (away from the engine), starting at this vehicle
						v = this->self_scope.v;
						break;
					case 0x01: // count forward (toward the engine), starting at this vehicle
						v = this->self_scope.v;
						count = -count;
						break;
					case 0x02: // count back, starting at the engine
						v = this->parent_scope.v;
						break;
					case 0x03: { // count back, starting at the first vehicle in this chain of vehicles with the same ID, as for vehicle variable 41
						const Vehicle *self = this->self_scope.v;
						for (const Vehicle *u = self->First(); u != self; u = u->Next()) {
							if (u->engine_type != self->engine_type) {
								v = nullptr;
							} else {
								if (v == nullptr) v = u;
							}
						}
						if (v == nullptr) v = self;
						break;
					}
				}
				this->relative_scope.SetVehicle(v->Move(count));
			}
			return &this->relative_scope;
		}
		default: return ResolverObject::GetScope(scope, relative);
	}
}

/**
 * Determines the livery of an engine.
 *
 * This always uses dual company colours independent of GUI settings. So it is desync-safe.
 *
 * @param engine Engine type
 * @param v Vehicle, nullptr in purchase list.
 * @return Livery to use
 */
static const Livery *LiveryHelper(EngineID engine, const Vehicle *v)
{
	const Livery *l;

	if (v == nullptr) {
		if (!Company::IsValidID(_current_company)) return nullptr;
		l = GetEngineLivery(engine, _current_company, INVALID_ENGINE, nullptr, LIT_ALL);
	} else if (v->IsGroundVehicle()) {
		l = GetEngineLivery(v->engine_type, v->owner, v->GetGroundVehicleCache()->first_engine, v, LIT_ALL);
	} else {
		l = GetEngineLivery(v->engine_type, v->owner, INVALID_ENGINE, v, LIT_ALL);
	}

	return l;
}

/**
 * Helper to get the position of a vehicle within a chain of vehicles.
 * @param v the vehicle to get the position of.
 * @param consecutive whether to look at the whole chain or the vehicles
 *                    with the same 'engine type'.
 * @return the position in the chain from front and tail and chain length.
 */
static uint32_t PositionHelper(const Vehicle *v, bool consecutive)
{
	const Vehicle *u;
	byte chain_before = 0;
	byte chain_after  = 0;

	for (u = v->First(); u != v; u = u->Next()) {
		chain_before++;
		if (consecutive && u->engine_type != v->engine_type) chain_before = 0;
	}

	while (u->Next() != nullptr && (!consecutive || u->Next()->engine_type == v->engine_type)) {
		chain_after++;
		u = u->Next();
	}

	return chain_before | chain_after << 8 | (chain_before + chain_after + consecutive) << 16;
}

static uint32_t VehicleGetVariable(Vehicle *v, const VehicleScopeResolver *object, byte variable, uint32_t parameter, bool *available)
{
	/* Calculated vehicle parameters */
	switch (variable) {
		case 0x25: // Get engine GRF ID
			return v->GetGRFID();

		case 0x40: // Get length of consist
			if (!HasBit(v->grf_cache.cache_valid, NCVV_POSITION_CONSIST_LENGTH)) {
				v->grf_cache.position_consist_length = PositionHelper(v, false);
				SetBit(v->grf_cache.cache_valid, NCVV_POSITION_CONSIST_LENGTH);
			}
			return v->grf_cache.position_consist_length;

		case 0x41: // Get length of same consecutive wagons
			if (!HasBit(v->grf_cache.cache_valid, NCVV_POSITION_SAME_ID_LENGTH)) {
				v->grf_cache.position_same_id_length = PositionHelper(v, true);
				SetBit(v->grf_cache.cache_valid, NCVV_POSITION_SAME_ID_LENGTH);
			}
			return v->grf_cache.position_same_id_length;

		case 0x42: { // Consist cargo information
			if (!HasBit(v->grf_cache.cache_valid, NCVV_CONSIST_CARGO_INFORMATION)) {
				std::array<uint8_t, NUM_CARGO> common_cargoes{};
				byte cargo_classes = 0;
				byte user_def_data = 0;

				for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
					if (v->type == VEH_TRAIN) user_def_data |= Train::From(u)->tcache.user_def_data;

					/* Skip empty engines */
					if (!u->GetEngine()->CanCarryCargo()) continue;

					cargo_classes |= CargoSpec::Get(u->cargo_type)->classes;
					common_cargoes[u->cargo_type]++;
				}

				/* Pick the most common cargo type */
				auto cargo_it = std::max_element(std::begin(common_cargoes), std::end(common_cargoes));
				/* Return CT_INVALID if nothing is carried */
				CargoID common_cargo_type = (*cargo_it == 0) ? (CargoID)CT_INVALID : static_cast<CargoID>(std::distance(std::begin(common_cargoes), cargo_it));

				/* Count subcargo types of common_cargo_type */
				std::array<uint8_t, UINT8_MAX + 1> common_subtypes{};
				for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
					/* Skip empty engines and engines not carrying common_cargo_type */
					if (u->cargo_type != common_cargo_type || !u->GetEngine()->CanCarryCargo()) continue;

					common_subtypes[u->cargo_subtype]++;
				}

				/* Pick the most common subcargo type*/
				auto subtype_it = std::max_element(std::begin(common_subtypes), std::end(common_subtypes));
				/* Return UINT8_MAX if nothing is carried */
				uint8_t common_subtype = (*subtype_it == 0) ? UINT8_MAX : static_cast<uint8_t>(std::distance(std::begin(common_subtypes), subtype_it));

				/* Note: We have to store the untranslated cargotype in the cache as the cache can be read by different NewGRFs,
				 *       which will need different translations */
				v->grf_cache.consist_cargo_information = cargo_classes | (common_cargo_type << 8) | (common_subtype << 16) | (user_def_data << 24);
				SetBit(v->grf_cache.cache_valid, NCVV_CONSIST_CARGO_INFORMATION);
			}

			/* The cargo translation is specific to the accessing GRF, and thus cannot be cached. */
			CargoID common_cargo_type = (v->grf_cache.consist_cargo_information >> 8) & 0xFF;

			/* Note:
			 *  - Unlike everywhere else the cargo translation table is only used since grf version 8, not 7.
			 *  - For translating the cargo type we need to use the GRF which is resolving the variable, which
			 *    is object->ro.grffile.
			 *    In case of CBID_TRAIN_ALLOW_WAGON_ATTACH this is not the same as v->GetGRF().
			 *  - The grffile == nullptr case only happens if this function is called for default vehicles.
			 *    And this is only done by CheckCaches().
			 */
			const GRFFile *grffile = object->ro.grffile;
			uint8_t common_bitnum = (common_cargo_type == CT_INVALID) ? 0xFF :
				(grffile == nullptr || grffile->grf_version < 8) ? CargoSpec::Get(common_cargo_type)->bitnum : grffile->cargo_map[common_cargo_type];

			return (v->grf_cache.consist_cargo_information & 0xFFFF00FF) | common_bitnum << 8;
		}

		case 0x43: // Company information
			if (!HasBit(v->grf_cache.cache_valid, NCVV_COMPANY_INFORMATION)) {
				v->grf_cache.company_information = GetCompanyInfo(v->owner, LiveryHelper(v->engine_type, v));
				SetBit(v->grf_cache.cache_valid, NCVV_COMPANY_INFORMATION);
			}
			return v->grf_cache.company_information;

		case 0x44: // Aircraft information
			if (v->type != VEH_AIRCRAFT || !Aircraft::From(v)->IsNormalAircraft()) return UINT_MAX;

			{
				const Vehicle *w = v->Next();
				assert(w != nullptr);
				uint16_t altitude = ClampTo<uint16_t>(v->z_pos - w->z_pos); // Aircraft height - shadow height
				byte airporttype = ATP_TTDP_LARGE;

				const Station *st = GetTargetAirportIfValid(Aircraft::From(v));

				if (st != nullptr && st->airport.tile != INVALID_TILE) {
					airporttype = st->airport.GetSpec()->ttd_airport_type;
				}

				return (ClampTo<uint8_t>(altitude) << 8) | airporttype;
			}

		case 0x45: { // Curvature info
			/* Format: xxxTxBxF
			 * F - previous wagon to current wagon, 0 if vehicle is first
			 * B - current wagon to next wagon, 0 if wagon is last
			 * T - previous wagon to next wagon, 0 in an S-bend
			 */
			if (!v->IsGroundVehicle()) return 0;

			const Vehicle *u_p = v->Previous();
			const Vehicle *u_n = v->Next();
			DirDiff f = (u_p == nullptr) ?  DIRDIFF_SAME : DirDifference(u_p->direction, v->direction);
			DirDiff b = (u_n == nullptr) ?  DIRDIFF_SAME : DirDifference(v->direction, u_n->direction);
			DirDiff t = ChangeDirDiff(f, b);

			return ((t > DIRDIFF_REVERSE ? t | 8 : t) << 16) |
			       ((b > DIRDIFF_REVERSE ? b | 8 : b) <<  8) |
			       ( f > DIRDIFF_REVERSE ? f | 8 : f);
		}

		case 0x46: // Motion counter
			return v->motion_counter;

		case 0x47: { // Vehicle cargo info
			/* Format: ccccwwtt
			 * tt - the cargo type transported by the vehicle,
			 *     translated if a translation table has been installed.
			 * ww - cargo unit weight in 1/16 tons, same as cargo prop. 0F.
			 * cccc - the cargo class value of the cargo transported by the vehicle.
			 */
			const CargoSpec *cs = CargoSpec::Get(v->cargo_type);

			/* Note:
			 * For translating the cargo type we need to use the GRF which is resolving the variable, which
			 * is object->ro.grffile.
			 * In case of CBID_TRAIN_ALLOW_WAGON_ATTACH this is not the same as v->GetGRF().
			 */
			return (cs->classes << 16) | (cs->weight << 8) | object->ro.grffile->cargo_map[v->cargo_type];
		}

		case 0x48: return v->GetEngine()->flags; // Vehicle Type Info
		case 0x49: return v->build_year.base();

		case 0x4A:
			switch (v->type) {
				case VEH_TRAIN: {
					RailType rt = GetTileRailType(v->tile);
					const RailTypeInfo *rti = GetRailTypeInfo(rt);
					return ((rti->flags & RTFB_CATENARY) ? 0x200 : 0) |
						(HasPowerOnRail(Train::From(v)->railtype, rt) ? 0x100 : 0) |
						GetReverseRailTypeTranslation(rt, object->ro.grffile);
				}

				case VEH_ROAD: {
					RoadType rt = GetRoadType(v->tile, GetRoadTramType(RoadVehicle::From(v)->roadtype));
					const RoadTypeInfo *rti = GetRoadTypeInfo(rt);
					return ((rti->flags & ROTFB_CATENARY) ? 0x200 : 0) |
						0x100 |
						GetReverseRoadTypeTranslation(rt, object->ro.grffile);
				}

				default:
					return 0;
			}

		case 0x4B: // Long date of last service
			return v->date_of_last_service_newgrf.base();

		case 0x4C: // Current maximum speed in NewGRF units
			if (!v->IsPrimaryVehicle()) return 0;
			return v->GetCurrentMaxSpeed();

		case 0x4D: // Position within articulated vehicle
			if (!HasBit(v->grf_cache.cache_valid, NCVV_POSITION_IN_VEHICLE)) {
				byte artic_before = 0;
				for (const Vehicle *u = v; u->IsArticulatedPart(); u = u->Previous()) artic_before++;
				byte artic_after = 0;
				for (const Vehicle *u = v; u->HasArticulatedPart(); u = u->Next()) artic_after++;
				v->grf_cache.position_in_vehicle = artic_before | artic_after << 8;
				SetBit(v->grf_cache.cache_valid, NCVV_POSITION_IN_VEHICLE);
			}
			return v->grf_cache.position_in_vehicle;

		/* Variables which use the parameter */
		case 0x60: // Count consist's engine ID occurrence
			if (v->type != VEH_TRAIN) return v->GetEngine()->grf_prop.local_id == parameter ? 1 : 0;

			{
				uint count = 0;
				for (; v != nullptr; v = v->Next()) {
					if (v->GetEngine()->grf_prop.local_id == parameter) count++;
				}
				return count;
			}

		case 0x61: // Get variable of n-th vehicle in chain [signed number relative to vehicle]
			if (!v->IsGroundVehicle() || parameter == 0x61) {
				/* Not available */
				break;
			}

			/* Only allow callbacks that don't change properties to avoid circular dependencies. */
			if (object->ro.callback == CBID_NO_CALLBACK || object->ro.callback == CBID_RANDOM_TRIGGER || object->ro.callback == CBID_TRAIN_ALLOW_WAGON_ATTACH ||
					object->ro.callback == CBID_VEHICLE_START_STOP_CHECK || object->ro.callback == CBID_VEHICLE_32DAY_CALLBACK || object->ro.callback == CBID_VEHICLE_COLOUR_MAPPING ||
					object->ro.callback == CBID_VEHICLE_SPAWN_VISUAL_EFFECT) {
				Vehicle *u = v->Move((int32_t)GetRegister(0x10F));
				if (u == nullptr) return 0; // available, but zero

				if (parameter == 0x5F) {
					/* This seems to be the only variable that makes sense to access via var 61, but is not handled by VehicleGetVariable */
					return (u->random_bits << 8) | u->waiting_triggers;
				} else {
					return VehicleGetVariable(u, object, parameter, GetRegister(0x10E), available);
				}
			}
			/* Not available */
			break;

		case 0x62: { // Curvature/position difference for n-th vehicle in chain [signed number relative to vehicle]
			/* Format: zzyyxxFD
			 * zz - Signed difference of z position between the selected and this vehicle.
			 * yy - Signed difference of y position between the selected and this vehicle.
			 * xx - Signed difference of x position between the selected and this vehicle.
			 * F  - Flags, bit 7 corresponds to VS_HIDDEN.
			 * D  - Dir difference, like in 0x45.
			 */
			if (!v->IsGroundVehicle()) return 0;

			const Vehicle *u = v->Move((int8_t)parameter);
			if (u == nullptr) return 0;

			/* Get direction difference. */
			bool prev = (int8_t)parameter < 0;
			uint32_t ret = prev ? DirDifference(u->direction, v->direction) : DirDifference(v->direction, u->direction);
			if (ret > DIRDIFF_REVERSE) ret |= 0x08;

			if (u->vehstatus & VS_HIDDEN) ret |= 0x80;

			/* Get position difference. */
			ret |= ((prev ? u->x_pos - v->x_pos : v->x_pos - u->x_pos) & 0xFF) << 8;
			ret |= ((prev ? u->y_pos - v->y_pos : v->y_pos - u->y_pos) & 0xFF) << 16;
			ret |= ((prev ? u->z_pos - v->z_pos : v->z_pos - u->z_pos) & 0xFF) << 24;

			return ret;
		}

		case 0x63:
			/* Tile compatibility wrt. arbitrary track-type
			 * Format:
			 *  bit 0: Type 'parameter' is known.
			 *  bit 1: Engines with type 'parameter' are compatible with this tile.
			 *  bit 2: Engines with type 'parameter' are powered on this tile.
			 *  bit 3: This tile has type 'parameter' or it is considered equivalent (alternate labels).
			 */
			switch (v->type) {
				case VEH_TRAIN: {
					RailType param_type = GetRailTypeTranslation(parameter, object->ro.grffile);
					if (param_type == INVALID_RAILTYPE) return 0x00;
					RailType tile_type = GetTileRailType(v->tile);
					if (tile_type == param_type) return 0x0F;
					return (HasPowerOnRail(param_type, tile_type) ? 0x04 : 0x00) |
							(IsCompatibleRail(param_type, tile_type) ? 0x02 : 0x00) |
							0x01;
				}
				case VEH_ROAD: {
					RoadTramType rtt = GetRoadTramType(RoadVehicle::From(v)->roadtype);
					RoadType param_type = GetRoadTypeTranslation(rtt, parameter, object->ro.grffile);
					if (param_type == INVALID_ROADTYPE) return 0x00;
					RoadType tile_type = GetRoadType(v->tile, rtt);
					if (tile_type == param_type) return 0x0F;
					return (HasPowerOnRoad(param_type, tile_type) ? 0x06 : 0x00) |
							0x01;
				}
				default: return 0x00;
			}

		case 0xFE:
		case 0xFF: {
			uint16_t modflags = 0;

			if (v->type == VEH_TRAIN) {
				const Train *t = Train::From(v);
				bool is_powered_wagon = HasBit(t->flags, VRF_POWEREDWAGON);
				const Train *u = is_powered_wagon ? t->First() : t; // for powered wagons the engine defines the type of engine (i.e. railtype)
				RailType railtype = GetRailType(v->tile);
				bool powered = t->IsEngine() || is_powered_wagon;
				bool has_power = HasPowerOnRail(u->railtype, railtype);

				if (powered && has_power) SetBit(modflags, 5);
				if (powered && !has_power) SetBit(modflags, 6);
				if (HasBit(t->flags, VRF_TOGGLE_REVERSE)) SetBit(modflags, 8);
			}
			if (HasBit(v->vehicle_flags, VF_CARGO_UNLOADING)) SetBit(modflags, 1);
			if (HasBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE)) SetBit(modflags, 10);

			return variable == 0xFE ? modflags : GB(modflags, 8, 8);
		}
	}

	/*
	 * General vehicle properties
	 *
	 * Some parts of the TTD Vehicle structure are omitted for various reasons
	 * (see http://marcin.ttdpatch.net/sv1codec/TTD-locations.html#_VehicleArray)
	 */
	switch (variable - 0x80) {
		case 0x00: return v->type + 0x10;
		case 0x01: return MapOldSubType(v);
		case 0x02: break; // not implemented
		case 0x03: break; // not implemented
		case 0x04: return v->index;
		case 0x05: return GB(v->index, 8, 8);
		case 0x06: break; // not implemented
		case 0x07: break; // not implemented
		case 0x08: break; // not implemented
		case 0x09: break; // not implemented
		case 0x0A: return v->current_order.MapOldOrder();
		case 0x0B: return v->current_order.GetDestination();
		case 0x0C: return v->GetNumOrders();
		case 0x0D: return v->cur_real_order_index;
		case 0x0E: break; // not implemented
		case 0x0F: break; // not implemented
		case 0x10:
		case 0x11: {
			uint ticks;
			if (v->current_order.IsType(OT_LOADING)) {
				ticks = v->load_unload_ticks;
			} else {
				switch (v->type) {
					case VEH_TRAIN:    ticks = Train::From(v)->wait_counter; break;
					case VEH_AIRCRAFT: ticks = Aircraft::From(v)->turn_counter; break;
					default:           ticks = 0; break;
				}
			}
			return (variable - 0x80) == 0x10 ? ticks : GB(ticks, 8, 8);
		}
		case 0x12: return ClampTo<uint16_t>(v->date_of_last_service_newgrf - CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR);
		case 0x13: return GB(ClampTo<uint16_t>(v->date_of_last_service_newgrf - CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR), 8, 8);
		case 0x14: return v->GetServiceInterval();
		case 0x15: return GB(v->GetServiceInterval(), 8, 8);
		case 0x16: return v->last_station_visited;
		case 0x17: return v->tick_counter;
		case 0x18:
		case 0x19: {
			uint max_speed;
			switch (v->type) {
				case VEH_AIRCRAFT:
					max_speed = Aircraft::From(v)->GetSpeedOldUnits(); // Convert to old units.
					break;

				default:
					max_speed = v->vcache.cached_max_speed;
					break;
			}
			return (variable - 0x80) == 0x18 ? max_speed : GB(max_speed, 8, 8);
		}
		case 0x1A: return v->x_pos;
		case 0x1B: return GB(v->x_pos, 8, 8);
		case 0x1C: return v->y_pos;
		case 0x1D: return GB(v->y_pos, 8, 8);
		case 0x1E: return v->z_pos;
		case 0x1F: return object->rotor_in_gui ? DIR_W : v->direction; // for rotors the spriteset contains animation frames, so NewGRF need a different way to tell the helicopter orientation.
		case 0x20: break; // not implemented
		case 0x21: break; // not implemented
		case 0x22: break; // not implemented
		case 0x23: break; // not implemented
		case 0x24: break; // not implemented
		case 0x25: break; // not implemented
		case 0x26: break; // not implemented
		case 0x27: break; // not implemented
		case 0x28: return 0; // cur_image is a potential desyncer due to Action1 in static NewGRFs.
		case 0x29: return 0; // cur_image is a potential desyncer due to Action1 in static NewGRFs.
		case 0x2A: break; // not implemented
		case 0x2B: break; // not implemented
		case 0x2C: break; // not implemented
		case 0x2D: break; // not implemented
		case 0x2E: break; // not implemented
		case 0x2F: break; // not implemented
		case 0x30: break; // not implemented
		case 0x31: break; // not implemented
		case 0x32: return v->vehstatus;
		case 0x33: return 0; // non-existent high byte of vehstatus
		case 0x34: return v->type == VEH_AIRCRAFT ? (v->cur_speed * 10) / 128 : v->cur_speed;
		case 0x35: return GB(v->type == VEH_AIRCRAFT ? (v->cur_speed * 10) / 128 : v->cur_speed, 8, 8);
		case 0x36: return v->subspeed;
		case 0x37: return v->acceleration;
		case 0x38: break; // not implemented
		case 0x39: return v->cargo_type;
		case 0x3A: return v->cargo_cap;
		case 0x3B: return GB(v->cargo_cap, 8, 8);
		case 0x3C: return ClampTo<uint16_t>(v->cargo.StoredCount());
		case 0x3D: return GB(ClampTo<uint16_t>(v->cargo.StoredCount()), 8, 8);
		case 0x3E: return v->cargo.GetFirstStation();
		case 0x3F: return ClampTo<uint8_t>(v->cargo.PeriodsInTransit());
		case 0x40: return ClampTo<uint16_t>(v->age);
		case 0x41: return GB(ClampTo<uint16_t>(v->age), 8, 8);
		case 0x42: return ClampTo<uint16_t>(v->max_age);
		case 0x43: return GB(ClampTo<uint16_t>(v->max_age), 8, 8);
		case 0x44: return (Clamp(v->build_year, CalendarTime::ORIGINAL_BASE_YEAR, CalendarTime::ORIGINAL_MAX_YEAR) - CalendarTime::ORIGINAL_BASE_YEAR).base();
		case 0x45: return v->unitnumber;
		case 0x46: return v->GetEngine()->grf_prop.local_id;
		case 0x47: return GB(v->GetEngine()->grf_prop.local_id, 8, 8);
		case 0x48:
			if (v->type != VEH_TRAIN || v->spritenum != 0xFD) return v->spritenum;
			return HasBit(Train::From(v)->flags, VRF_REVERSE_DIRECTION) ? 0xFE : 0xFD;

		case 0x49: return v->day_counter;
		case 0x4A: return v->breakdowns_since_last_service;
		case 0x4B: return v->breakdown_ctr;
		case 0x4C: return v->breakdown_delay;
		case 0x4D: return v->breakdown_chance;
		case 0x4E: return v->reliability;
		case 0x4F: return GB(v->reliability, 8, 8);
		case 0x50: return v->reliability_spd_dec;
		case 0x51: return GB(v->reliability_spd_dec, 8, 8);
		case 0x52: return ClampTo<int32_t>(v->GetDisplayProfitThisYear());
		case 0x53: return GB(ClampTo<int32_t>(v->GetDisplayProfitThisYear()),  8, 24);
		case 0x54: return GB(ClampTo<int32_t>(v->GetDisplayProfitThisYear()), 16, 16);
		case 0x55: return GB(ClampTo<int32_t>(v->GetDisplayProfitThisYear()), 24,  8);
		case 0x56: return ClampTo<int32_t>(v->GetDisplayProfitLastYear());
		case 0x57: return GB(ClampTo<int32_t>(v->GetDisplayProfitLastYear()),  8, 24);
		case 0x58: return GB(ClampTo<int32_t>(v->GetDisplayProfitLastYear()), 16, 16);
		case 0x59: return GB(ClampTo<int32_t>(v->GetDisplayProfitLastYear()), 24,  8);
		case 0x5A: return v->Next() == nullptr ? INVALID_VEHICLE : v->Next()->index;
		case 0x5B: break; // not implemented
		case 0x5C: return ClampTo<int32_t>(v->value);
		case 0x5D: return GB(ClampTo<int32_t>(v->value),  8, 24);
		case 0x5E: return GB(ClampTo<int32_t>(v->value), 16, 16);
		case 0x5F: return GB(ClampTo<int32_t>(v->value), 24,  8);
		case 0x60: break; // not implemented
		case 0x61: break; // not implemented
		case 0x62: break; // vehicle specific, see below
		case 0x63: break; // not implemented
		case 0x64: break; // vehicle specific, see below
		case 0x65: break; // vehicle specific, see below
		case 0x66: break; // vehicle specific, see below
		case 0x67: break; // vehicle specific, see below
		case 0x68: break; // vehicle specific, see below
		case 0x69: break; // vehicle specific, see below
		case 0x6A: break; // not implemented
		case 0x6B: break; // not implemented
		case 0x6C: break; // not implemented
		case 0x6D: break; // not implemented
		case 0x6E: break; // not implemented
		case 0x6F: break; // not implemented
		case 0x70: break; // not implemented
		case 0x71: break; // not implemented
		case 0x72: return v->cargo_subtype;
		case 0x73: break; // vehicle specific, see below
		case 0x74: break; // vehicle specific, see below
		case 0x75: break; // vehicle specific, see below
		case 0x76: break; // vehicle specific, see below
		case 0x77: break; // vehicle specific, see below
		case 0x78: break; // not implemented
		case 0x79: break; // not implemented
		case 0x7A: return v->random_bits;
		case 0x7B: return v->waiting_triggers;
		case 0x7C: break; // vehicle specific, see below
		case 0x7D: break; // vehicle specific, see below
		case 0x7E: break; // not implemented
		case 0x7F: break; // vehicle specific, see below
	}

	/* Vehicle specific properties */
	switch (v->type) {
		case VEH_TRAIN: {
			Train *t = Train::From(v);
			switch (variable - 0x80) {
				case 0x62: return t->track;
				case 0x66: return t->railtype;
				case 0x73: return 0x80 + VEHICLE_LENGTH - t->gcache.cached_veh_length;
				case 0x74: return t->gcache.cached_power;
				case 0x75: return GB(t->gcache.cached_power,  8, 24);
				case 0x76: return GB(t->gcache.cached_power, 16, 16);
				case 0x77: return GB(t->gcache.cached_power, 24,  8);
				case 0x7C: return t->First()->index;
				case 0x7D: return GB(t->First()->index, 8, 8);
				case 0x7F: return 0; // Used for vehicle reversing hack in TTDP
			}
			break;
		}

		case VEH_ROAD: {
			RoadVehicle *rv = RoadVehicle::From(v);
			switch (variable - 0x80) {
				case 0x62: return rv->state;
				case 0x64: return rv->blocked_ctr;
				case 0x65: return GB(rv->blocked_ctr, 8, 8);
				case 0x66: return rv->overtaking;
				case 0x67: return rv->overtaking_ctr;
				case 0x68: return rv->crashed_ctr;
				case 0x69: return GB(rv->crashed_ctr, 8, 8);
			}
			break;
		}

		case VEH_SHIP: {
			Ship *s = Ship::From(v);
			switch (variable - 0x80) {
				case 0x62: return s->state;
			}
			break;
		}

		case VEH_AIRCRAFT: {
			Aircraft *a = Aircraft::From(v);
			switch (variable - 0x80) {
				case 0x62: return MapAircraftMovementState(a);  // Current movement state
				case 0x63: return a->targetairport;             // Airport to which the action refers
				case 0x66: return MapAircraftMovementAction(a); // Current movement action
			}
			break;
		}

		default: break;
	}

	Debug(grf, 1, "Unhandled vehicle variable 0x{:X}, type 0x{:X}", variable, (uint)v->type);

	*available = false;
	return UINT_MAX;
}

/* virtual */ uint32_t VehicleScopeResolver::GetVariable(byte variable, [[maybe_unused]] uint32_t parameter, bool *available) const
{
	if (this->v == nullptr) {
		/* Vehicle does not exist, so we're in a purchase list */
		switch (variable) {
			case 0x43: return GetCompanyInfo(_current_company, LiveryHelper(this->self_type, nullptr)); // Owner information
			case 0x46: return 0;               // Motion counter
			case 0x47: { // Vehicle cargo info
				const Engine *e = Engine::Get(this->self_type);
				CargoID cargo_type = e->GetDefaultCargoType();
				if (IsValidCargoID(cargo_type)) {
					const CargoSpec *cs = CargoSpec::Get(cargo_type);
					return (cs->classes << 16) | (cs->weight << 8) | this->ro.grffile->cargo_map[cargo_type];
				} else {
					return 0x000000FF;
				}
			}
			case 0x48: return Engine::Get(this->self_type)->flags; // Vehicle Type Info
			case 0x49: return TimerGameCalendar::year.base(); // 'Long' format build year
			case 0x4B: return TimerGameCalendar::date.base(); // Long date of last service
			case 0x92: return ClampTo<uint16_t>(TimerGameCalendar::date - CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR); // Date of last service
			case 0x93: return GB(ClampTo<uint16_t>(TimerGameCalendar::date - CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR), 8, 8);
			case 0xC4: return (Clamp(TimerGameCalendar::year, CalendarTime::ORIGINAL_BASE_YEAR, CalendarTime::ORIGINAL_MAX_YEAR) - CalendarTime::ORIGINAL_BASE_YEAR).base(); // Build year
			case 0xC6: return Engine::Get(this->self_type)->grf_prop.local_id;
			case 0xC7: return GB(Engine::Get(this->self_type)->grf_prop.local_id, 8, 8);
			case 0xDA: return INVALID_VEHICLE; // Next vehicle
			case 0xF2: return 0; // Cargo subtype
		}

		*available = false;
		return UINT_MAX;
	}

	return VehicleGetVariable(const_cast<Vehicle*>(this->v), this, variable, parameter, available);
}


/* virtual */ const SpriteGroup *VehicleResolverObject::ResolveReal(const RealSpriteGroup *group) const
{
	const Vehicle *v = this->self_scope.v;

	if (v == nullptr) {
		if (!group->loading.empty()) return group->loading[0];
		if (!group->loaded.empty())  return group->loaded[0];
		return nullptr;
	}

	bool in_motion = !v->First()->current_order.IsType(OT_LOADING);

	uint totalsets = in_motion ? (uint)group->loaded.size() : (uint)group->loading.size();

	if (totalsets == 0) return nullptr;

	uint set = (v->cargo.StoredCount() * totalsets) / std::max<uint16_t>(1u, v->cargo_cap);
	set = std::min(set, totalsets - 1);

	return in_motion ? group->loaded[set] : group->loading[set];
}

GrfSpecFeature VehicleResolverObject::GetFeature() const
{
	switch (Engine::Get(this->self_scope.self_type)->type) {
		case VEH_TRAIN: return GSF_TRAINS;
		case VEH_ROAD: return GSF_ROADVEHICLES;
		case VEH_SHIP: return GSF_SHIPS;
		case VEH_AIRCRAFT: return GSF_AIRCRAFT;
		default: return GSF_INVALID;
	}
}

uint32_t VehicleResolverObject::GetDebugID() const
{
	return Engine::Get(this->self_scope.self_type)->grf_prop.local_id;
}

/**
 * Get the grf file associated with an engine type.
 * @param engine_type Engine to query.
 * @return grf file associated with the engine.
 */
static const GRFFile *GetEngineGrfFile(EngineID engine_type)
{
	const Engine *e = Engine::Get(engine_type);
	return (e != nullptr) ? e->GetGRF() : nullptr;
}

/**
 * Resolver of a vehicle (chain).
 * @param engine_type Engine type
 * @param v %Vehicle being resolved.
 * @param wagon_override Application of wagon overrides.
 * @param rotor_in_gui Helicopter rotor is drawn in GUI.
 * @param callback Callback ID.
 * @param callback_param1 First parameter (var 10) of the callback.
 * @param callback_param2 Second parameter (var 18) of the callback.
 */
VehicleResolverObject::VehicleResolverObject(EngineID engine_type, const Vehicle *v, WagonOverride wagon_override, bool rotor_in_gui,
		CallbackID callback, uint32_t callback_param1, uint32_t callback_param2)
	: ResolverObject(GetEngineGrfFile(engine_type), callback, callback_param1, callback_param2),
	self_scope(*this, engine_type, v, rotor_in_gui),
	parent_scope(*this, engine_type, ((v != nullptr) ? v->First() : v), rotor_in_gui),
	relative_scope(*this, engine_type, v, rotor_in_gui),
	cached_relative_count(0)
{
	if (wagon_override == WO_SELF) {
		this->root_spritegroup = GetWagonOverrideSpriteSet(engine_type, CT_DEFAULT, engine_type);
	} else {
		if (wagon_override != WO_NONE && v != nullptr && v->IsGroundVehicle()) {
			assert(v->engine_type == engine_type); // overrides make little sense with fake scopes

			/* For trains we always use cached value, except for callbacks because the override spriteset
			 * to use may be different than the one cached. It happens for callback 0x15 (refit engine),
			 * as v->cargo_type is temporary changed to the new type */
			if (wagon_override == WO_CACHED && v->type == VEH_TRAIN) {
				this->root_spritegroup = Train::From(v)->tcache.cached_override;
			} else {
				this->root_spritegroup = GetWagonOverrideSpriteSet(v->engine_type, v->cargo_type, v->GetGroundVehicleCache()->first_engine);
			}
		}

		if (this->root_spritegroup == nullptr) {
			const Engine *e = Engine::Get(engine_type);
			CargoID cargo = v != nullptr ? v->cargo_type : CT_PURCHASE;
			assert(cargo < lengthof(e->grf_prop.spritegroup));
			this->root_spritegroup = e->grf_prop.spritegroup[cargo] != nullptr ? e->grf_prop.spritegroup[cargo] : e->grf_prop.spritegroup[CT_DEFAULT];
		}
	}
}



void GetCustomEngineSprite(EngineID engine, const Vehicle *v, Direction direction, EngineImageType image_type, VehicleSpriteSeq *result)
{
	VehicleResolverObject object(engine, v, VehicleResolverObject::WO_CACHED, false, CBID_NO_CALLBACK);
	result->Clear();

	bool sprite_stack = HasBit(EngInfo(engine)->misc_flags, EF_SPRITE_STACK);
	uint max_stack = sprite_stack ? lengthof(result->seq) : 1;
	for (uint stack = 0; stack < max_stack; ++stack) {
		object.ResetState();
		object.callback_param1 = image_type | (stack << 8);
		const SpriteGroup *group = object.Resolve();
		uint32_t reg100 = sprite_stack ? GetRegister(0x100) : 0;
		if (group != nullptr && group->GetNumResults() != 0) {
			result->seq[result->count].sprite = group->GetResult() + (direction % group->GetNumResults());
			result->seq[result->count].pal    = GB(reg100, 0, 16); // zero means default recolouring
			result->count++;
		}
		if (!HasBit(reg100, 31)) break;
	}
}


void GetRotorOverrideSprite(EngineID engine, const struct Aircraft *v, EngineImageType image_type, VehicleSpriteSeq *result)
{
	const Engine *e = Engine::Get(engine);

	/* Only valid for helicopters */
	assert(e->type == VEH_AIRCRAFT);
	assert(!(e->u.air.subtype & AIR_CTOL));

	/* We differ from TTDPatch by resolving the sprite using the primary vehicle 'v', and not using the rotor vehicle 'v->Next()->Next()'.
	 * TTDPatch copies some variables between the vehicles each time, to somehow synchronize the rotor vehicle with the primary vehicle.
	 * We use 'rotor_in_gui' to replicate when the variables differ.
	 * But some other variables like 'rotor state' and 'rotor speed' are not available in OpenTTD, while they are in TTDPatch. */
	bool rotor_in_gui = image_type != EIT_ON_MAP;
	VehicleResolverObject object(engine, v, VehicleResolverObject::WO_SELF, rotor_in_gui, CBID_NO_CALLBACK);
	result->Clear();
	uint rotor_pos = v == nullptr || rotor_in_gui ? 0 : v->Next()->Next()->state;

	bool sprite_stack = HasBit(e->info.misc_flags, EF_SPRITE_STACK);
	uint max_stack = sprite_stack ? lengthof(result->seq) : 1;
	for (uint stack = 0; stack < max_stack; ++stack) {
		object.ResetState();
		object.callback_param1 = image_type | (stack << 8);
		const SpriteGroup *group = object.Resolve();
		uint32_t reg100 = sprite_stack ? GetRegister(0x100) : 0;
		if (group != nullptr && group->GetNumResults() != 0) {
			result->seq[result->count].sprite = group->GetResult() + (rotor_pos % group->GetNumResults());
			result->seq[result->count].pal    = GB(reg100, 0, 16); // zero means default recolouring
			result->count++;
		}
		if (!HasBit(reg100, 31)) break;
	}
}


/**
 * Check if a wagon is currently using a wagon override
 * @param v The wagon to check
 * @return true if it is using an override, false otherwise
 */
bool UsesWagonOverride(const Vehicle *v)
{
	assert(v->type == VEH_TRAIN);
	return Train::From(v)->tcache.cached_override != nullptr;
}

/**
 * Evaluate a newgrf callback for vehicles
 * @param callback The callback to evaluate
 * @param param1   First parameter of the callback
 * @param param2   Second parameter of the callback
 * @param engine   Engine type of the vehicle to evaluate the callback for
 * @param v        The vehicle to evaluate the callback for, or nullptr if it doesn't exist yet
 * @return The value the callback returned, or CALLBACK_FAILED if it failed
 */
uint16_t GetVehicleCallback(CallbackID callback, uint32_t param1, uint32_t param2, EngineID engine, const Vehicle *v)
{
	VehicleResolverObject object(engine, v, VehicleResolverObject::WO_UNCACHED, false, callback, param1, param2);
	return object.ResolveCallback();
}

/**
 * Evaluate a newgrf callback for vehicles with a different vehicle for parent scope.
 * @param callback The callback to evaluate
 * @param param1   First parameter of the callback
 * @param param2   Second parameter of the callback
 * @param engine   Engine type of the vehicle to evaluate the callback for
 * @param v        The vehicle to evaluate the callback for, or nullptr if it doesn't exist yet
 * @param parent   The vehicle to use for parent scope
 * @return The value the callback returned, or CALLBACK_FAILED if it failed
 */
uint16_t GetVehicleCallbackParent(CallbackID callback, uint32_t param1, uint32_t param2, EngineID engine, const Vehicle *v, const Vehicle *parent)
{
	VehicleResolverObject object(engine, v, VehicleResolverObject::WO_NONE, false, callback, param1, param2);
	object.parent_scope.SetVehicle(parent);
	return object.ResolveCallback();
}


/* Callback 36 handlers */
int GetVehicleProperty(const Vehicle *v, PropertyID property, int orig_value, bool is_signed)
{
	return GetEngineProperty(v->engine_type, property, orig_value, v, is_signed);
}


int GetEngineProperty(EngineID engine, PropertyID property, int orig_value, const Vehicle *v, bool is_signed)
{
	uint16_t callback = GetVehicleCallback(CBID_VEHICLE_MODIFY_PROPERTY, property, 0, engine, v);
	if (callback != CALLBACK_FAILED) {
		if (is_signed) {
			/* Sign extend 15 bit integer */
			return static_cast<int16_t>(callback << 1) / 2;
		} else {
			return callback;
		}
	}

	return orig_value;
}

/**
 * Test for vehicle build probablity type.
 * @param v Vehicle whose build probability to test.
 * @param type Build probability type to test for.
 * @returns True iff the probability result says so.
 */
bool TestVehicleBuildProbability(Vehicle *v, EngineID engine, BuildProbabilityType type)
{
	uint16_t p = GetVehicleCallback(CBID_VEHICLE_BUILD_PROBABILITY, std::underlying_type<BuildProbabilityType>::type(type), 0, engine, v);
	if (p == CALLBACK_FAILED) return false;

	const uint16_t PROBABILITY_RANGE = 100;
	return p + RandomRange(PROBABILITY_RANGE) >= PROBABILITY_RANGE;
}

static void DoTriggerVehicle(Vehicle *v, VehicleTrigger trigger, uint16_t base_random_bits, bool first)
{
	/* We can't trigger a non-existent vehicle... */
	assert(v != nullptr);

	VehicleResolverObject object(v->engine_type, v, VehicleResolverObject::WO_CACHED, false, CBID_RANDOM_TRIGGER);
	object.waiting_triggers = v->waiting_triggers | trigger;
	v->waiting_triggers = object.waiting_triggers; // store now for var 5F

	const SpriteGroup *group = object.Resolve();
	if (group == nullptr) return;

	/* Store remaining triggers. */
	v->waiting_triggers = object.GetRemainingTriggers();

	/* Rerandomise bits. Scopes other than SELF are invalid for rerandomisation. For bug-to-bug-compatibility with TTDP we ignore the scope. */
	uint16_t new_random_bits = Random();
	uint32_t reseed = object.GetReseedSum();
	v->random_bits &= ~reseed;
	v->random_bits |= (first ? new_random_bits : base_random_bits) & reseed;

	switch (trigger) {
		case VEHICLE_TRIGGER_NEW_CARGO:
			/* All vehicles in chain get ANY_NEW_CARGO trigger now.
			 * So we call it for the first one and they will recurse.
			 * Indexing part of vehicle random bits needs to be
			 * same for all triggered vehicles in the chain (to get
			 * all the random-cargo wagons carry the same cargo,
			 * i.e.), so we give them all the NEW_CARGO triggered
			 * vehicle's portion of random bits. */
			assert(first);
			DoTriggerVehicle(v->First(), VEHICLE_TRIGGER_ANY_NEW_CARGO, new_random_bits, false);
			break;

		case VEHICLE_TRIGGER_DEPOT:
			/* We now trigger the next vehicle in chain recursively.
			 * The random bits portions may be different for each
			 * vehicle in chain. */
			if (v->Next() != nullptr) DoTriggerVehicle(v->Next(), trigger, 0, true);
			break;

		case VEHICLE_TRIGGER_EMPTY:
			/* We now trigger the next vehicle in chain
			 * recursively.  The random bits portions must be same
			 * for each vehicle in chain, so we give them all
			 * first chained vehicle's portion of random bits. */
			if (v->Next() != nullptr) DoTriggerVehicle(v->Next(), trigger, first ? new_random_bits : base_random_bits, false);
			break;

		case VEHICLE_TRIGGER_ANY_NEW_CARGO:
			/* Now pass the trigger recursively to the next vehicle
			 * in chain. */
			assert(!first);
			if (v->Next() != nullptr) DoTriggerVehicle(v->Next(), VEHICLE_TRIGGER_ANY_NEW_CARGO, base_random_bits, false);
			break;

		case VEHICLE_TRIGGER_CALLBACK_32:
			/* Do not do any recursion */
			break;
	}
}

void TriggerVehicle(Vehicle *v, VehicleTrigger trigger)
{
	if (trigger == VEHICLE_TRIGGER_DEPOT) {
		/* store that the vehicle entered a depot this tick */
		VehicleEnteredDepotThisTick(v);
	}

	v->InvalidateNewGRFCacheOfChain();
	DoTriggerVehicle(v, trigger, 0, true);
	v->InvalidateNewGRFCacheOfChain();
}

/* Functions for changing the order of vehicle purchase lists */

struct ListOrderChange {
	EngineID engine;
	uint target;      ///< local ID
};

static std::vector<ListOrderChange> _list_order_changes;

/**
 * Record a vehicle ListOrderChange.
 * @param engine Engine to move
 * @param target Local engine ID to move \a engine in front of
 * @note All sorting is done later in CommitVehicleListOrderChanges
 */
void AlterVehicleListOrder(EngineID engine, uint target)
{
	/* Add the list order change to a queue */
	_list_order_changes.push_back({engine, target});
}

/**
 * Comparator function to sort engines via scope-GRFID and local ID.
 * @param a left side
 * @param b right side
 * @return comparison result
 */
static bool EnginePreSort(const EngineID &a, const EngineID &b)
{
	const EngineIDMapping &id_a = _engine_mngr.at(a);
	const EngineIDMapping &id_b = _engine_mngr.at(b);

	/* 1. Sort by engine type */
	if (id_a.type != id_b.type) return (int)id_a.type < (int)id_b.type;

	/* 2. Sort by scope-GRFID */
	if (id_a.grfid != id_b.grfid) return id_a.grfid < id_b.grfid;

	/* 3. Sort by local ID */
	return (int)id_a.internal_id < (int)id_b.internal_id;
}

/**
 * Deternine default engine sorting and execute recorded ListOrderChanges from AlterVehicleListOrder.
 */
void CommitVehicleListOrderChanges()
{
	/* Pre-sort engines by scope-grfid and local index */
	std::vector<EngineID> ordering;
	for (const Engine *e : Engine::Iterate()) {
		ordering.push_back(e->index);
	}
	std::sort(ordering.begin(), ordering.end(), EnginePreSort);

	/* Apply Insertion-Sort operations */
	for (const ListOrderChange &it : _list_order_changes) {
		EngineID source = it.engine;
		uint local_target = it.target;

		const EngineIDMapping *id_source = _engine_mngr.data() + source;
		if (id_source->internal_id == local_target) continue;

		EngineID target = _engine_mngr.GetID(id_source->type, local_target, id_source->grfid);
		if (target == INVALID_ENGINE) continue;

		int source_index = find_index(ordering, source);
		int target_index = find_index(ordering, target);

		assert(source_index >= 0 && target_index >= 0);
		assert(source_index != target_index);

		EngineID *list = ordering.data();
		if (source_index < target_index) {
			--target_index;
			for (int i = source_index; i < target_index; ++i) list[i] = list[i + 1];
			list[target_index] = source;
		} else {
			for (int i = source_index; i > target_index; --i) list[i] = list[i - 1];
			list[target_index] = source;
		}
	}

	/* Store final sort-order */
	uint index = 0;
	for (const EngineID &eid : ordering) {
		Engine::Get(eid)->list_position = index;
		++index;
	}

	/* Clear out the queue */
	_list_order_changes.clear();
	_list_order_changes.shrink_to_fit();
}

/**
 * Fill the grf_cache of the given vehicle.
 * @param v The vehicle to fill the cache for.
 */
void FillNewGRFVehicleCache(const Vehicle *v)
{
	VehicleResolverObject ro(v->engine_type, v, VehicleResolverObject::WO_NONE);

	/* These variables we have to check; these are the ones with a cache. */
	static const int cache_entries[][2] = {
		{ 0x40, NCVV_POSITION_CONSIST_LENGTH },
		{ 0x41, NCVV_POSITION_SAME_ID_LENGTH },
		{ 0x42, NCVV_CONSIST_CARGO_INFORMATION },
		{ 0x43, NCVV_COMPANY_INFORMATION },
		{ 0x4D, NCVV_POSITION_IN_VEHICLE },
	};
	static_assert(NCVV_END == lengthof(cache_entries));

	/* Resolve all the variables, so their caches are set. */
	for (size_t i = 0; i < lengthof(cache_entries); i++) {
		/* Only resolve when the cache isn't valid. */
		if (HasBit(v->grf_cache.cache_valid, cache_entries[i][1])) continue;
		bool stub;
		ro.GetScope(VSG_SCOPE_SELF)->GetVariable(cache_entries[i][0], 0, &stub);
	}

	/* Make sure really all bits are set. */
	assert(v->grf_cache.cache_valid == (1 << NCVV_END) - 1);
}