Files @ r28356:5479dee3539c
Branch filter:

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

Patric Stout
Fix: [CI] patch in SHF_COMPRESSED symbol for our Linux Generic binaries (#11651)
  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
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r8999:fbaa01d3cee2
r8999:fbaa01d3cee2
r6264:e0e78c40628e
r10208:ef8fcc3dc4ca
r6264:e0e78c40628e
r8116:df67d3c5e4fd
r9936:5832128332ee
r8144:1432edd15267
r8212:13ec7a6b1407
r15604:1622d4de58e8
r8363:42190addf5ac
r28159:2f140179d2ed
r14248:a9050881acd7
r23147:1747db3d2973
r23698:1872cc5b7dd7
r23877:800799329701
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r26094:7572e88decb3
r26102:502baaa2877d
r26102:502baaa2877d
r26102:502baaa2877d
r26102:502baaa2877d
r6264:e0e78c40628e
r8264:d493cb51fe8a
r8264:d493cb51fe8a
r21383:942c32fb8b0e
r21383:942c32fb8b0e
r12680:58e06ff4bbd2
r12680:58e06ff4bbd2
r12680:58e06ff4bbd2
r12680:58e06ff4bbd2
r15610:623a23fb6560
r15610:623a23fb6560
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r13211:4ba95564ba64
r9889:bd274fe4b267
r22867:9bff1c966805
r22867:9bff1c966805
r18668:b656d614c4fd
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r10207:a1fc2f2a33db
r9889:bd274fe4b267
r9889:bd274fe4b267
r10207:a1fc2f2a33db
r9889:bd274fe4b267
r14364:c8fe08980d51
r9889:bd274fe4b267
r13208:40382e8abf19
r13208:40382e8abf19
r13208:40382e8abf19
r9889:bd274fe4b267
r10207:a1fc2f2a33db
r10207:a1fc2f2a33db
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r13208:40382e8abf19
r9889:bd274fe4b267
r19944:25a78576fb5e
r13208:40382e8abf19
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r23698:1872cc5b7dd7
r19944:25a78576fb5e
r13208:40382e8abf19
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r19944:25a78576fb5e
r13208:40382e8abf19
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r9889:bd274fe4b267
r13211:4ba95564ba64
r9889:bd274fe4b267
r8628:e4c2822288b0
r15610:623a23fb6560
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r20188:c7660e0c9b5b
r20188:c7660e0c9b5b
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r23607:36c15679007d
r18824:4a8ec7bae9c5
r23607:36c15679007d
r20188:c7660e0c9b5b
r20188:c7660e0c9b5b
r18824:4a8ec7bae9c5
r20188:c7660e0c9b5b
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r20188:c7660e0c9b5b
r23607:36c15679007d
r20188:c7660e0c9b5b
r20188:c7660e0c9b5b
r18824:4a8ec7bae9c5
r24597:afde5721a3b6
r20054:152d076eb07b
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r20188:c7660e0c9b5b
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r15610:623a23fb6560
r9928:94206085695f
r9928:94206085695f
r10193:9b282b96cd44
r20188:c7660e0c9b5b
r20188:c7660e0c9b5b
r20188:c7660e0c9b5b
r9928:94206085695f
r10193:9b282b96cd44
r9928:94206085695f
r10198:a2df0dee10c1
r9928:94206085695f
r23607:36c15679007d
r20188:c7660e0c9b5b
r17175:412ca7ec4689
r10193:9b282b96cd44
r17175:412ca7ec4689
r10193:9b282b96cd44
r10193:9b282b96cd44
r20188:c7660e0c9b5b
r9928:94206085695f
r9928:94206085695f
r23607:36c15679007d
r20188:c7660e0c9b5b
r17175:412ca7ec4689
r10193:9b282b96cd44
r17175:412ca7ec4689
r10193:9b282b96cd44
r10193:9b282b96cd44
r9928:94206085695f
r9928:94206085695f
r24597:afde5721a3b6
r9928:94206085695f
r9928:94206085695f
r20054:152d076eb07b
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r21229:bf509b0caedd
r9928:94206085695f
r9928:94206085695f
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r6264:e0e78c40628e
r22867:9bff1c966805
r22867:9bff1c966805
r9725:d6d7b42bd986
r14816:761adf600201
r24513:ba5551156e4e
r18241:a4322e3af754
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r6264:e0e78c40628e
r6264:e0e78c40628e
r6264:e0e78c40628e
r6264:e0e78c40628e
r6264:e0e78c40628e
r6264:e0e78c40628e
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r26178:733038a553ce
r25716:ab9b7d7dd0ba
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r6264:e0e78c40628e
r16339:e90c1dadabf0
r6264:e0e78c40628e
r10193:9b282b96cd44
r6264:e0e78c40628e
r6264:e0e78c40628e
r6264:e0e78c40628e
r6264:e0e78c40628e
r10193:9b282b96cd44
r6264:e0e78c40628e
r22867:9bff1c966805
r14014:448f8c2f27bc
r6264:e0e78c40628e
r14014:448f8c2f27bc
r9725:d6d7b42bd986
r14816:761adf600201
r28159:2f140179d2ed
r28159:2f140179d2ed
r28159:2f140179d2ed
r28159:2f140179d2ed
r28159:2f140179d2ed
r28159:2f140179d2ed
r28159:2f140179d2ed
r28159:2f140179d2ed
r28159:2f140179d2ed
r6264:e0e78c40628e
r27421:e8c2cdc1e8e6
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r10193:9b282b96cd44
r10193:9b282b96cd44
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r6264:e0e78c40628e
r23607:36c15679007d
r19097:ec2b0cea1565
r9725:d6d7b42bd986
r18630:60f0459747eb
r9725:d6d7b42bd986
r6264:e0e78c40628e
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r9725:d6d7b42bd986
r10193:9b282b96cd44
r9725:d6d7b42bd986
r18630:60f0459747eb
r9725:d6d7b42bd986
r6264:e0e78c40628e
r6264:e0e78c40628e
r15610:623a23fb6560
r15610:623a23fb6560
r8997:fc5459ffbe17
r10207:a1fc2f2a33db
r19233:bd16563de8bd
r23023:7b8669afd1db
r18051:7bf4a53ac5e6
r8997:fc5459ffbe17
r19233:bd16563de8bd
r8997:fc5459ffbe17
r17175:412ca7ec4689
r9725:d6d7b42bd986
r18051:7bf4a53ac5e6
r18051:7bf4a53ac5e6
r12292:c3b6baef441a
r8997:fc5459ffbe17
r18051:7bf4a53ac5e6
r8997:fc5459ffbe17
r8997:fc5459ffbe17
r19233:bd16563de8bd
r19233:bd16563de8bd
r19233:bd16563de8bd
r8997:fc5459ffbe17
r18051:7bf4a53ac5e6
r10207:a1fc2f2a33db
r18051:7bf4a53ac5e6
r8997:fc5459ffbe17
r8997:fc5459ffbe17
r18051:7bf4a53ac5e6
r18051:7bf4a53ac5e6
r8997:fc5459ffbe17
r18051:7bf4a53ac5e6
r18051:7bf4a53ac5e6
r18051:7bf4a53ac5e6
r18051:7bf4a53ac5e6
r18051:7bf4a53ac5e6
r8997:fc5459ffbe17
r8997:fc5459ffbe17
r15610:623a23fb6560
r15610:623a23fb6560
r9928:94206085695f
r9928:94206085695f
r19944:25a78576fb5e
r10193:9b282b96cd44
r9928:94206085695f
r9928:94206085695f
r10193:9b282b96cd44
r9928:94206085695f
r23607:36c15679007d
r9928:94206085695f
r9928:94206085695f
r11917:612c11f7ab47
r18051:7bf4a53ac5e6
r19233:bd16563de8bd
r18051:7bf4a53ac5e6
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r10193:9b282b96cd44
r27421:e8c2cdc1e8e6
r24822:4bce81fd6257
r24822:4bce81fd6257
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r24607:a9b760e80cd3
r9928:94206085695f
r9928:94206085695f
r26125:9a63e6c142ba
r26749:31ad365154bc
r9928:94206085695f
r9928:94206085695f
r26125:9a63e6c142ba
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r18630:60f0459747eb
r18630:60f0459747eb
r13953:6e01902256f4
r26125:9a63e6c142ba
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r12109:90df01928018
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r15610:623a23fb6560
r15610:623a23fb6560
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r15610:623a23fb6560
r15610:623a23fb6560
r9928:94206085695f
r23607:36c15679007d
r13060:e57594b0ca84
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r17161:f31e5319d6ba
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r15610:623a23fb6560
r15610:623a23fb6560
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r11090:9276cea703d4
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r26109:9d7a08d936b2
r9928:94206085695f
r9928:94206085695f
r27606:02acf14253b2
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r26791:8e217aa7f11b
r9928:94206085695f
r12680:58e06ff4bbd2
r12680:58e06ff4bbd2
r9928:94206085695f
r12680:58e06ff4bbd2
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r15610:623a23fb6560
r15610:623a23fb6560
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r11090:9276cea703d4
r10193:9b282b96cd44
r12292:c3b6baef441a
r12292:c3b6baef441a
r10193:9b282b96cd44
r26948:8bceb871d3e5
r10193:9b282b96cd44
r10193:9b282b96cd44
r23607:36c15679007d
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r23607:36c15679007d
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r17161:f31e5319d6ba
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r23877:800799329701
r23877:800799329701
r10193:9b282b96cd44
r10193:9b282b96cd44
r10194:7e7dbb50ce31
r26111:5721922c714f
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r26111:5721922c714f
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r15610:623a23fb6560
r15610:623a23fb6560
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r11090:9276cea703d4
r9928:94206085695f
r9928:94206085695f
r10193:9b282b96cd44
r9928:94206085695f
r26948:8bceb871d3e5
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r27737:728d55b97775
r9928:94206085695f
r9928:94206085695f
r23607:36c15679007d
r9928:94206085695f
r11980:193f7a6b6e37
r23607:36c15679007d
r11980:193f7a6b6e37
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r11980:193f7a6b6e37
r23607:36c15679007d
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r11980:193f7a6b6e37
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r23607:36c15679007d
r9928:94206085695f
r23607:36c15679007d
r9928:94206085695f
r9968:45fe01d99177
r9928:94206085695f
r9968:45fe01d99177
r12296:564aa4953d26
r23607:36c15679007d
r9928:94206085695f
r23607:36c15679007d
r9928:94206085695f
r9969:c56a278fc945
r9969:c56a278fc945
r15890:3dc179e59aac
r9969:c56a278fc945
r23607:36c15679007d
r9969:c56a278fc945
r9969:c56a278fc945
r23607:36c15679007d
r9928:94206085695f
r9969:c56a278fc945
r9928:94206085695f
r23607:36c15679007d
r15890:3dc179e59aac
r15890:3dc179e59aac
r15890:3dc179e59aac
r23607:36c15679007d
r15890:3dc179e59aac
r15890:3dc179e59aac
r23607:36c15679007d
r17161:f31e5319d6ba
r9969:c56a278fc945
r9969:c56a278fc945
r23607:36c15679007d
r9928:94206085695f
r9928:94206085695f
r9969:c56a278fc945
r16778:660bd976d69f
r9928:94206085695f
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r23607:36c15679007d
r23607:36c15679007d
r9928:94206085695f
r9969:c56a278fc945
r9969:c56a278fc945
r17161:f31e5319d6ba
r9928:94206085695f
r17328:c2138f8c095c
r17328:c2138f8c095c
r17328:c2138f8c095c
r17328:c2138f8c095c
r23607:36c15679007d
r9969:c56a278fc945
r9969:c56a278fc945
r9928:94206085695f
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r12296:564aa4953d26
r9969:c56a278fc945
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9969:c56a278fc945
r9969:c56a278fc945
r17328:c2138f8c095c
r9969:c56a278fc945
r9969:c56a278fc945
r23607:36c15679007d
r9969:c56a278fc945
r9928:94206085695f
r9969:c56a278fc945
r9928:94206085695f
r9969:c56a278fc945
r26111:5721922c714f
r9969:c56a278fc945
r23607:36c15679007d
r9928:94206085695f
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9928:94206085695f
r9928:94206085695f
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r25450:7e9533370994
r9969:c56a278fc945
r9928:94206085695f
r11337:9b00fd51efbb
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r23607:36c15679007d
r9969:c56a278fc945
r9928:94206085695f
r10193:9b282b96cd44
r9969:c56a278fc945
r11337:9b00fd51efbb
r23838:bfeaabaa7b1d
r11337:9b00fd51efbb
r26111:5721922c714f
r9969:c56a278fc945
r23607:36c15679007d
r25450:7e9533370994
r9969:c56a278fc945
r9928:94206085695f
r18824:4a8ec7bae9c5
r18824:4a8ec7bae9c5
r9928:94206085695f
r9928:94206085695f
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r9969:c56a278fc945
r12296:564aa4953d26
r23607:36c15679007d
r9928:94206085695f
r23607:36c15679007d
r9928:94206085695f
r9969:c56a278fc945
r25590:6544087fd869
r9969:c56a278fc945
r9969:c56a278fc945
r9968:45fe01d99177
r9968:45fe01d99177
r9928:94206085695f
r9968:45fe01d99177
r9968:45fe01d99177
r9928:94206085695f
r23607:36c15679007d
r26111:5721922c714f
r23607:36c15679007d
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r23607:36c15679007d
r10193:9b282b96cd44
r9928:94206085695f
r9928:94206085695f
r23607:36c15679007d
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r10193:9b282b96cd44
r9928:94206085695f
r23877:800799329701
r23877:800799329701
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r15610:623a23fb6560
r15610:623a23fb6560
r10193:9b282b96cd44
r26095:00c14d52e378
r26115:02430a86c873
r13057:58af81fcdcf8
r9928:94206085695f
r26115:02430a86c873
r9928:94206085695f
r26115:02430a86c873
r23607:36c15679007d
r11944:3b8f9f948e8d
r14805:8c416234ced2
r14805:8c416234ced2
r14805:8c416234ced2
r12084:850e45fd8022
r9928:94206085695f
r10193:9b282b96cd44
r10193:9b282b96cd44
r12290:442d5d533a57
r12292:c3b6baef441a
r12290:442d5d533a57
r12290:442d5d533a57
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r26311:99c3ff8d01cc
r10193:9b282b96cd44
r11917:612c11f7ab47
r11908:0875f47fab11
r9928:94206085695f
r25226:099b6b8941ab
r25226:099b6b8941ab
r25226:099b6b8941ab
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r23607:36c15679007d
r18051:7bf4a53ac5e6
r19233:bd16563de8bd
r18051:7bf4a53ac5e6
r18051:7bf4a53ac5e6
r23607:36c15679007d
r9928:94206085695f
r9928:94206085695f
r26948:8bceb871d3e5
r14816:761adf600201
r14816:761adf600201
r9928:94206085695f
r10193:9b282b96cd44
r9928:94206085695f
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r19465:c2b6bb045744
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r10193:9b282b96cd44
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r9928:94206085695f
r26111:5721922c714f
r9928:94206085695f
r9928:94206085695f
r12609:70f427be341a
r9928:94206085695f
r9928:94206085695f
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r26095:00c14d52e378
r26115:02430a86c873
r26115:02430a86c873
r26115:02430a86c873
r26115:02430a86c873
r15604:1622d4de58e8
r15604:1622d4de58e8
r26115:02430a86c873
r15604:1622d4de58e8
r15604:1622d4de58e8
r23607:36c15679007d
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r18020:2cc4cd085970
r15604:1622d4de58e8
r26315:6348bc21fe19
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r26115:02430a86c873
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r19298:9d81b51d8e91
r19298:9d81b51d8e91
r19983:2df3f9831582
r23147:1747db3d2973
r23147:1747db3d2973
r23147:1747db3d2973
r19298:9d81b51d8e91
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
r15604:1622d4de58e8
/*
 * 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 autoreplace_cmd.cpp Deals with autoreplace execution but not the setup */

#include "stdafx.h"
#include "company_func.h"
#include "train.h"
#include "command_func.h"
#include "engine_func.h"
#include "vehicle_func.h"
#include "autoreplace_func.h"
#include "autoreplace_gui.h"
#include "articulated_vehicles.h"
#include "core/bitmath_func.hpp"
#include "core/random_func.hpp"
#include "vehiclelist.h"
#include "road.h"
#include "ai/ai.hpp"
#include "news_func.h"
#include "strings_func.h"
#include "autoreplace_cmd.h"
#include "group_cmd.h"
#include "order_cmd.h"
#include "train_cmd.h"
#include "vehicle_cmd.h"

#include "table/strings.h"

#include "safeguards.h"

extern void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index);
extern void ChangeVehicleNews(VehicleID from_index, VehicleID to_index);
extern void ChangeVehicleViewWindow(VehicleID from_index, VehicleID to_index);

/**
 * Figure out if two engines got at least one type of cargo in common (refitting if needed)
 * @param engine_a one of the EngineIDs
 * @param engine_b the other EngineID
 * @return true if they can both carry the same type of cargo (or at least one of them got no capacity at all)
 */
static bool EnginesHaveCargoInCommon(EngineID engine_a, EngineID engine_b)
{
	CargoTypes available_cargoes_a = GetUnionOfArticulatedRefitMasks(engine_a, true);
	CargoTypes available_cargoes_b = GetUnionOfArticulatedRefitMasks(engine_b, true);
	return (available_cargoes_a == 0 || available_cargoes_b == 0 || (available_cargoes_a & available_cargoes_b) != 0);
}

/**
 * Checks some basic properties whether autoreplace is allowed
 * @param from Origin engine
 * @param to Destination engine
 * @param company Company to check for
 * @return true if autoreplace is allowed
 */
bool CheckAutoreplaceValidity(EngineID from, EngineID to, CompanyID company)
{
	assert(Engine::IsValidID(from) && Engine::IsValidID(to));

	const Engine *e_from = Engine::Get(from);
	const Engine *e_to = Engine::Get(to);
	VehicleType type = e_from->type;

	/* check that the new vehicle type is available to the company and its type is the same as the original one */
	if (!IsEngineBuildable(to, type, company)) return false;

	switch (type) {
		case VEH_TRAIN: {
			/* make sure the railtypes are compatible */
			if ((GetRailTypeInfo(e_from->u.rail.railtype)->compatible_railtypes & GetRailTypeInfo(e_to->u.rail.railtype)->compatible_railtypes) == 0) return false;

			/* make sure we do not replace wagons with engines or vice versa */
			if ((e_from->u.rail.railveh_type == RAILVEH_WAGON) != (e_to->u.rail.railveh_type == RAILVEH_WAGON)) return false;
			break;
		}

		case VEH_ROAD:
			/* make sure the roadtypes are compatible */
			if ((GetRoadTypeInfo(e_from->u.road.roadtype)->powered_roadtypes & GetRoadTypeInfo(e_to->u.road.roadtype)->powered_roadtypes) == ROADTYPES_NONE) return false;

			/* make sure that we do not replace a tram with a normal road vehicles or vice versa */
			if (HasBit(e_from->info.misc_flags, EF_ROAD_TRAM) != HasBit(e_to->info.misc_flags, EF_ROAD_TRAM)) return false;
			break;

		case VEH_AIRCRAFT:
			/* make sure that we do not replace a plane with a helicopter or vice versa */
			if ((e_from->u.air.subtype & AIR_CTOL) != (e_to->u.air.subtype & AIR_CTOL)) return false;
			break;

		default: break;
	}

	/* the engines needs to be able to carry the same cargo */
	return EnginesHaveCargoInCommon(from, to);
}

/**
 * Check the capacity of all vehicles in a chain and spread cargo if needed.
 * @param v The vehicle to check.
 * @pre You can only do this if the consist is not loading or unloading. It
 *      must not carry reserved cargo, nor cargo to be unloaded or transferred.
 */
void CheckCargoCapacity(Vehicle *v)
{
	assert(v == nullptr || v->First() == v);

	for (Vehicle *src = v; src != nullptr; src = src->Next()) {
		assert(src->cargo.TotalCount() == src->cargo.ActionCount(VehicleCargoList::MTA_KEEP));

		/* Do we need to more cargo away? */
		if (src->cargo.TotalCount() <= src->cargo_cap) continue;

		/* We need to move a particular amount. Try that on the other vehicles. */
		uint to_spread = src->cargo.TotalCount() - src->cargo_cap;
		for (Vehicle *dest = v; dest != nullptr && to_spread != 0; dest = dest->Next()) {
			assert(dest->cargo.TotalCount() == dest->cargo.ActionCount(VehicleCargoList::MTA_KEEP));
			if (dest->cargo.TotalCount() >= dest->cargo_cap || dest->cargo_type != src->cargo_type) continue;

			uint amount = std::min(to_spread, dest->cargo_cap - dest->cargo.TotalCount());
			src->cargo.Shift(amount, &dest->cargo);
			to_spread -= amount;
		}

		/* Any left-overs will be thrown away, but not their feeder share. */
		if (src->cargo_cap < src->cargo.TotalCount()) src->cargo.Truncate(src->cargo.TotalCount() - src->cargo_cap);
	}
}

/**
 * Transfer cargo from a single (articulated )old vehicle to the new vehicle chain
 * @param old_veh Old vehicle that will be sold
 * @param new_head Head of the completely constructed new vehicle chain
 * @param part_of_chain The vehicle is part of a train
 * @pre You can only do this if both consists are not loading or unloading.
 *      They must not carry reserved cargo, nor cargo to be unloaded or
 *      transferred.
 */
static void TransferCargo(Vehicle *old_veh, Vehicle *new_head, bool part_of_chain)
{
	assert(!part_of_chain || new_head->IsPrimaryVehicle());
	/* Loop through source parts */
	for (Vehicle *src = old_veh; src != nullptr; src = src->Next()) {
		assert(src->cargo.TotalCount() == src->cargo.ActionCount(VehicleCargoList::MTA_KEEP));
		if (!part_of_chain && src->type == VEH_TRAIN && src != old_veh && src != Train::From(old_veh)->other_multiheaded_part && !src->IsArticulatedPart()) {
			/* Skip vehicles, which do not belong to old_veh */
			src = src->GetLastEnginePart();
			continue;
		}
		if (src->cargo_type >= NUM_CARGO || src->cargo.TotalCount() == 0) continue;

		/* Find free space in the new chain */
		for (Vehicle *dest = new_head; dest != nullptr && src->cargo.TotalCount() > 0; dest = dest->Next()) {
			assert(dest->cargo.TotalCount() == dest->cargo.ActionCount(VehicleCargoList::MTA_KEEP));
			if (!part_of_chain && dest->type == VEH_TRAIN && dest != new_head && dest != Train::From(new_head)->other_multiheaded_part && !dest->IsArticulatedPart()) {
				/* Skip vehicles, which do not belong to new_head */
				dest = dest->GetLastEnginePart();
				continue;
			}
			if (dest->cargo_type != src->cargo_type) continue;

			uint amount = std::min(src->cargo.TotalCount(), dest->cargo_cap - dest->cargo.TotalCount());
			if (amount <= 0) continue;

			src->cargo.Shift(amount, &dest->cargo);
		}
	}

	/* Update train weight etc., the old vehicle will be sold anyway */
	if (part_of_chain && new_head->type == VEH_TRAIN) Train::From(new_head)->ConsistChanged(CCF_LOADUNLOAD);
}

/**
 * Tests whether refit orders that applied to v will also apply to the new vehicle type
 * @param v The vehicle to be replaced
 * @param engine_type The type we want to replace with
 * @return true iff all refit orders stay valid
 */
static bool VerifyAutoreplaceRefitForOrders(const Vehicle *v, EngineID engine_type)
{
	CargoTypes union_refit_mask_a = GetUnionOfArticulatedRefitMasks(v->engine_type, false);
	CargoTypes union_refit_mask_b = GetUnionOfArticulatedRefitMasks(engine_type, false);

	const Vehicle *u = (v->type == VEH_TRAIN) ? v->First() : v;
	for (const Order *o : u->Orders()) {
		if (!o->IsRefit() || o->IsAutoRefit()) continue;
		CargoID cargo_type = o->GetRefitCargo();

		if (!HasBit(union_refit_mask_a, cargo_type)) continue;
		if (!HasBit(union_refit_mask_b, cargo_type)) return false;
	}

	return true;
}

/**
 * Gets the index of the first refit order that is incompatible with the requested engine type
 * @param v The vehicle to be replaced
 * @param engine_type The type we want to replace with
 * @return index of the incompatible order or -1 if none were found
 */
static int GetIncompatibleRefitOrderIdForAutoreplace(const Vehicle *v, EngineID engine_type)
{
	CargoTypes union_refit_mask = GetUnionOfArticulatedRefitMasks(engine_type, false);

	const Order *o;
	const Vehicle *u = (v->type == VEH_TRAIN) ? v->First() : v;

	const OrderList *orders = u->orders;
	if (orders == nullptr) return -1;
	for (VehicleOrderID i = 0; i < orders->GetNumOrders(); i++) {
		o = orders->GetOrderAt(i);
		if (!o->IsRefit()) continue;
		if (!HasBit(union_refit_mask, o->GetRefitCargo())) return i;
	}

	return -1;
}

/**
 * Function to find what type of cargo to refit to when autoreplacing
 * @param *v Original vehicle that is being replaced.
 * @param engine_type The EngineID of the vehicle that is being replaced to
 * @param part_of_chain The vehicle is part of a train
 * @return The cargo type to replace to
 *    CT_NO_REFIT is returned if no refit is needed
 *    CT_INVALID is returned when both old and new vehicle got cargo capacity and refitting the new one to the old one's cargo type isn't possible
 */
static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type, bool part_of_chain)
{
	CargoTypes available_cargo_types, union_mask;
	GetArticulatedRefitMasks(engine_type, true, &union_mask, &available_cargo_types);

	if (union_mask == 0) return CT_NO_REFIT; // Don't try to refit an engine with no cargo capacity

	CargoID cargo_type;
	CargoTypes cargo_mask = GetCargoTypesOfArticulatedVehicle(v, &cargo_type);
	if (!HasAtMostOneBit(cargo_mask)) {
		CargoTypes new_engine_default_cargoes = GetCargoTypesOfArticulatedParts(engine_type);
		if ((cargo_mask & new_engine_default_cargoes) == cargo_mask) {
			return CT_NO_REFIT; // engine_type is already a mixed cargo type which matches the incoming vehicle by default, no refit required
		}

		return CT_INVALID; // We cannot refit to mixed cargoes in an automated way
	}

	if (!IsValidCargoID(cargo_type)) {
		if (v->type != VEH_TRAIN) return CT_NO_REFIT; // If the vehicle does not carry anything at all, every replacement is fine.

		if (!part_of_chain) return CT_NO_REFIT;

		/* the old engine didn't have cargo capacity, but the new one does
		 * now we will figure out what cargo the train is carrying and refit to fit this */

		for (v = v->First(); v != nullptr; v = v->Next()) {
			if (!v->GetEngine()->CanCarryCargo()) continue;
			/* Now we found a cargo type being carried on the train and we will see if it is possible to carry to this one */
			if (HasBit(available_cargo_types, v->cargo_type)) return v->cargo_type;
		}

		return CT_NO_REFIT; // We failed to find a cargo type on the old vehicle and we will not refit the new one
	} else {
		if (!HasBit(available_cargo_types, cargo_type)) return CT_INVALID; // We can't refit the vehicle to carry the cargo we want

		if (part_of_chain && !VerifyAutoreplaceRefitForOrders(v, engine_type)) return CT_INVALID; // Some refit orders lose their effect

		return cargo_type;
	}
}

/**
 * Get the EngineID of the replacement for a vehicle
 * @param v The vehicle to find a replacement for
 * @param c The vehicle's owner (it's faster to forward the pointer than refinding it)
 * @param always_replace Always replace, even if not old.
 * @param[out] e the EngineID of the replacement. INVALID_ENGINE if no replacement is found
 * @return Error if the engine to build is not available
 */
static CommandCost GetNewEngineType(const Vehicle *v, const Company *c, bool always_replace, EngineID &e)
{
	assert(v->type != VEH_TRAIN || !v->IsArticulatedPart());

	e = INVALID_ENGINE;

	if (v->type == VEH_TRAIN && Train::From(v)->IsRearDualheaded()) {
		/* we build the rear ends of multiheaded trains with the front ones */
		return CommandCost();
	}

	bool replace_when_old;
	e = EngineReplacementForCompany(c, v->engine_type, v->group_id, &replace_when_old);
	if (!always_replace && replace_when_old && !v->NeedsAutorenewing(c, false)) e = INVALID_ENGINE;

	/* Autoreplace, if engine is available */
	if (e != INVALID_ENGINE && IsEngineBuildable(e, v->type, _current_company)) {
		return CommandCost();
	}

	/* Autorenew if needed */
	if (v->NeedsAutorenewing(c)) e = v->engine_type;

	/* Nothing to do or all is fine? */
	if (e == INVALID_ENGINE || IsEngineBuildable(e, v->type, _current_company)) return CommandCost();

	/* The engine we need is not available. Report error to user */
	return CommandCost(STR_ERROR_RAIL_VEHICLE_NOT_AVAILABLE + v->type);
}

/**
 * Builds and refits a replacement vehicle
 * Important: The old vehicle is still in the original vehicle chain (used for determining the cargo when the old vehicle did not carry anything, but the new one does)
 * @param old_veh A single (articulated/multiheaded) vehicle that shall be replaced.
 * @param new_vehicle Returns the newly build and refitted vehicle
 * @param part_of_chain The vehicle is part of a train
 * @return cost or error
 */
static CommandCost BuildReplacementVehicle(Vehicle *old_veh, Vehicle **new_vehicle, bool part_of_chain)
{
	*new_vehicle = nullptr;

	/* Shall the vehicle be replaced? */
	const Company *c = Company::Get(_current_company);
	EngineID e;
	CommandCost cost = GetNewEngineType(old_veh, c, true, e);
	if (cost.Failed()) return cost;
	if (e == INVALID_ENGINE) return CommandCost(); // neither autoreplace is set, nor autorenew is triggered

	/* Does it need to be refitted */
	CargoID refit_cargo = GetNewCargoTypeForReplace(old_veh, e, part_of_chain);
	if (!IsValidCargoID(refit_cargo)) {
		if (!IsLocalCompany()) return CommandCost();

		SetDParam(0, old_veh->index);

		int order_id = GetIncompatibleRefitOrderIdForAutoreplace(old_veh, e);
		if (order_id != -1) {
			/* Orders contained a refit order that is incompatible with the new vehicle. */
			SetDParam(1, STR_ERROR_AUTOREPLACE_INCOMPATIBLE_REFIT);
			SetDParam(2, order_id + 1); // 1-based indexing for display
		} else {
			/* Current cargo is incompatible with the new vehicle. */
			SetDParam(1, STR_ERROR_AUTOREPLACE_INCOMPATIBLE_CARGO);
			SetDParam(2, CargoSpec::Get(old_veh->cargo_type)->name);
		}

		AddVehicleAdviceNewsItem(STR_NEWS_VEHICLE_AUTORENEW_FAILED, old_veh->index);
		return CommandCost();
	}

	/* Build the new vehicle */
	VehicleID new_veh_id;
	std::tie(cost, new_veh_id, std::ignore, std::ignore, std::ignore) = Command<CMD_BUILD_VEHICLE>::Do(DC_EXEC | DC_AUTOREPLACE, old_veh->tile, e, true, CT_INVALID, INVALID_CLIENT_ID);
	if (cost.Failed()) return cost;

	Vehicle *new_veh = Vehicle::Get(new_veh_id);
	*new_vehicle = new_veh;

	/* Refit the vehicle if needed */
	if (refit_cargo != CT_NO_REFIT) {
		byte subtype = GetBestFittingSubType(old_veh, new_veh, refit_cargo);

		cost.AddCost(std::get<0>(Command<CMD_REFIT_VEHICLE>::Do(DC_EXEC, new_veh->index, refit_cargo, subtype, false, false, 0)));
		assert(cost.Succeeded()); // This should be ensured by GetNewCargoTypeForReplace()
	}

	/* Try to reverse the vehicle, but do not care if it fails as the new type might not be reversible */
	if (new_veh->type == VEH_TRAIN && HasBit(Train::From(old_veh)->flags, VRF_REVERSE_DIRECTION)) {
		Command<CMD_REVERSE_TRAIN_DIRECTION>::Do(DC_EXEC, new_veh->index, true);
	}

	return cost;
}

/**
 * Issue a start/stop command
 * @param v a vehicle
 * @param evaluate_callback shall the start/stop callback be evaluated?
 * @return success or error
 */
static inline CommandCost DoCmdStartStopVehicle(const Vehicle *v, bool evaluate_callback)
{
	return Command<CMD_START_STOP_VEHICLE>::Do(DC_EXEC | DC_AUTOREPLACE, v->index, evaluate_callback);
}

/**
 * Issue a train vehicle move command
 * @param v The vehicle to move
 * @param after The vehicle to insert 'v' after, or nullptr to start new chain
 * @param flags the command flags to use
 * @param whole_chain move all vehicles following 'v' (true), or only 'v' (false)
 * @return success or error
 */
static inline CommandCost CmdMoveVehicle(const Vehicle *v, const Vehicle *after, DoCommandFlag flags, bool whole_chain)
{
	return Command<CMD_MOVE_RAIL_VEHICLE>::Do(flags | DC_NO_CARGO_CAP_CHECK, v->index, after != nullptr ? after->index : INVALID_VEHICLE, whole_chain);
}

/**
 * Copy head specific things to the new vehicle chain after it was successfully constructed
 * @param old_head The old front vehicle (no wagons attached anymore)
 * @param new_head The new head of the completely replaced vehicle chain
 * @param flags the command flags to use
 */
static CommandCost CopyHeadSpecificThings(Vehicle *old_head, Vehicle *new_head, DoCommandFlag flags)
{
	CommandCost cost = CommandCost();

	/* Share orders */
	if (cost.Succeeded() && old_head != new_head) cost.AddCost(Command<CMD_CLONE_ORDER>::Do(DC_EXEC, CO_SHARE, new_head->index, old_head->index));

	/* Copy group membership */
	if (cost.Succeeded() && old_head != new_head) cost.AddCost(std::get<0>(Command<CMD_ADD_VEHICLE_GROUP>::Do(DC_EXEC, old_head->group_id, new_head->index, false, VehicleListIdentifier{})));

	/* Perform start/stop check whether the new vehicle suits newgrf restrictions etc. */
	if (cost.Succeeded()) {
		/* Start the vehicle, might be denied by certain things */
		assert((new_head->vehstatus & VS_STOPPED) != 0);
		cost.AddCost(DoCmdStartStopVehicle(new_head, true));

		/* Stop the vehicle again, but do not care about evil newgrfs allowing starting but not stopping :p */
		if (cost.Succeeded()) cost.AddCost(DoCmdStartStopVehicle(new_head, false));
	}

	/* Last do those things which do never fail (resp. we do not care about), but which are not undo-able */
	if (cost.Succeeded() && old_head != new_head && (flags & DC_EXEC) != 0) {
		/* Copy other things which cannot be copied by a command and which shall not stay resetted from the build vehicle command */
		new_head->CopyVehicleConfigAndStatistics(old_head);
		GroupStatistics::AddProfitLastYear(new_head);

		/* Switch vehicle windows/news to the new vehicle, so they are not closed/deleted when the old vehicle is sold */
		ChangeVehicleViewports(old_head->index, new_head->index);
		ChangeVehicleViewWindow(old_head->index, new_head->index);
		ChangeVehicleNews(old_head->index, new_head->index);
	}

	return cost;
}

/**
 * Replace a single unit in a free wagon chain
 * @param single_unit vehicle to let autoreplace/renew operator on
 * @param flags command flags
 * @param nothing_to_do is set to 'false' when something was done (only valid when not failed)
 * @return cost or error
 */
static CommandCost ReplaceFreeUnit(Vehicle **single_unit, DoCommandFlag flags, bool *nothing_to_do)
{
	Train *old_v = Train::From(*single_unit);
	assert(!old_v->IsArticulatedPart() && !old_v->IsRearDualheaded());

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, (Money)0);

	/* Build and refit replacement vehicle */
	Vehicle *new_v = nullptr;
	cost.AddCost(BuildReplacementVehicle(old_v, &new_v, false));

	/* Was a new vehicle constructed? */
	if (cost.Succeeded() && new_v != nullptr) {
		*nothing_to_do = false;

		if ((flags & DC_EXEC) != 0) {
			/* Move the new vehicle behind the old */
			CmdMoveVehicle(new_v, old_v, DC_EXEC, false);

			/* Take over cargo
			 * Note: We do only transfer cargo from the old to the new vehicle.
			 *       I.e. we do not transfer remaining cargo to other vehicles.
			 *       Else you would also need to consider moving cargo to other free chains,
			 *       or doing the same in ReplaceChain(), which would be quite troublesome.
			 */
			TransferCargo(old_v, new_v, false);

			*single_unit = new_v;

			AI::NewEvent(old_v->owner, new ScriptEventVehicleAutoReplaced(old_v->index, new_v->index));
		}

		/* Sell the old vehicle */
		cost.AddCost(Command<CMD_SELL_VEHICLE>::Do(flags, old_v->index, false, false, INVALID_CLIENT_ID));

		/* If we are not in DC_EXEC undo everything */
		if ((flags & DC_EXEC) == 0) {
			Command<CMD_SELL_VEHICLE>::Do(DC_EXEC, new_v->index, false, false, INVALID_CLIENT_ID);
		}
	}

	return cost;
}

/**
 * Replace a whole vehicle chain
 * @param chain vehicle chain to let autoreplace/renew operator on
 * @param flags command flags
 * @param wagon_removal remove wagons when the resulting chain occupies more tiles than the old did
 * @param nothing_to_do is set to 'false' when something was done (only valid when not failed)
 * @return cost or error
 */
static CommandCost ReplaceChain(Vehicle **chain, DoCommandFlag flags, bool wagon_removal, bool *nothing_to_do)
{
	Vehicle *old_head = *chain;
	assert(old_head->IsPrimaryVehicle());

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, (Money)0);

	if (old_head->type == VEH_TRAIN) {
		/* Store the length of the old vehicle chain, rounded up to whole tiles */
		uint16_t old_total_length = CeilDiv(Train::From(old_head)->gcache.cached_total_length, TILE_SIZE) * TILE_SIZE;

		int num_units = 0; ///< Number of units in the chain
		for (Train *w = Train::From(old_head); w != nullptr; w = w->GetNextUnit()) num_units++;

		Train **old_vehs = CallocT<Train *>(num_units); ///< Will store vehicles of the old chain in their order
		Train **new_vehs = CallocT<Train *>(num_units); ///< New vehicles corresponding to old_vehs or nullptr if no replacement
		Money *new_costs = MallocT<Money>(num_units);   ///< Costs for buying and refitting the new vehicles

		/* Collect vehicles and build replacements
		 * Note: The replacement vehicles can only successfully build as long as the old vehicles are still in their chain */
		int i;
		Train *w;
		for (w = Train::From(old_head), i = 0; w != nullptr; w = w->GetNextUnit(), i++) {
			assert(i < num_units);
			old_vehs[i] = w;

			CommandCost ret = BuildReplacementVehicle(old_vehs[i], (Vehicle**)&new_vehs[i], true);
			cost.AddCost(ret);
			if (cost.Failed()) break;

			new_costs[i] = ret.GetCost();
			if (new_vehs[i] != nullptr) *nothing_to_do = false;
		}
		Train *new_head = (new_vehs[0] != nullptr ? new_vehs[0] : old_vehs[0]);

		/* Note: When autoreplace has already failed here, old_vehs[] is not completely initialized. But it is also not needed. */
		if (cost.Succeeded()) {
			/* Separate the head, so we can start constructing the new chain */
			Train *second = Train::From(old_head)->GetNextUnit();
			if (second != nullptr) cost.AddCost(CmdMoveVehicle(second, nullptr, DC_EXEC | DC_AUTOREPLACE, true));

			assert(Train::From(new_head)->GetNextUnit() == nullptr);

			/* Append engines to the new chain
			 * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time.
			 * That way we also have less trouble when exceeding the unitnumber limit.
			 * OTOH the vehicle attach callback is more expensive this way :s */
			Train *last_engine = nullptr; ///< Shall store the last engine unit after this step
			if (cost.Succeeded()) {
				for (int i = num_units - 1; i > 0; i--) {
					Train *append = (new_vehs[i] != nullptr ? new_vehs[i] : old_vehs[i]);

					if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) continue;

					if (new_vehs[i] != nullptr) {
						/* Move the old engine to a separate row with DC_AUTOREPLACE. Else
						 * moving the wagon in front may fail later due to unitnumber limit.
						 * (We have to attach wagons without DC_AUTOREPLACE.) */
						CmdMoveVehicle(old_vehs[i], nullptr, DC_EXEC | DC_AUTOREPLACE, false);
					}

					if (last_engine == nullptr) last_engine = append;
					cost.AddCost(CmdMoveVehicle(append, new_head, DC_EXEC, false));
					if (cost.Failed()) break;
				}
				if (last_engine == nullptr) last_engine = new_head;
			}

			/* When wagon removal is enabled and the new engines without any wagons are already longer than the old, we have to fail */
			if (cost.Succeeded() && wagon_removal && new_head->gcache.cached_total_length > old_total_length) cost = CommandCost(STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT);

			/* Append/insert wagons into the new vehicle chain
			 * We do this from back to front, so we can stop when wagon removal or maximum train length (i.e. from mammoth-train setting) is triggered.
			 */
			if (cost.Succeeded()) {
				for (int i = num_units - 1; i > 0; i--) {
					assert(last_engine != nullptr);
					Vehicle *append = (new_vehs[i] != nullptr ? new_vehs[i] : old_vehs[i]);

					if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) {
						/* Insert wagon after 'last_engine' */
						CommandCost res = CmdMoveVehicle(append, last_engine, DC_EXEC, false);

						/* When we allow removal of wagons, either the move failing due
						 * to the train becoming too long, or the train becoming longer
						 * would move the vehicle to the empty vehicle chain. */
						if (wagon_removal && (res.Failed() ? res.GetErrorMessage() == STR_ERROR_TRAIN_TOO_LONG : new_head->gcache.cached_total_length > old_total_length)) {
							CmdMoveVehicle(append, nullptr, DC_EXEC | DC_AUTOREPLACE, false);
							break;
						}

						cost.AddCost(res);
						if (cost.Failed()) break;
					} else {
						/* We have reached 'last_engine', continue with the next engine towards the front */
						assert(append == last_engine);
						last_engine = last_engine->GetPrevUnit();
					}
				}
			}

			/* Sell superfluous new vehicles that could not be inserted. */
			if (cost.Succeeded() && wagon_removal) {
				assert(new_head->gcache.cached_total_length <= _settings_game.vehicle.max_train_length * TILE_SIZE);
				for (int i = 1; i < num_units; i++) {
					Vehicle *wagon = new_vehs[i];
					if (wagon == nullptr) continue;
					if (wagon->First() == new_head) break;

					assert(RailVehInfo(wagon->engine_type)->railveh_type == RAILVEH_WAGON);

					/* Sell wagon */
					[[maybe_unused]] CommandCost ret = Command<CMD_SELL_VEHICLE>::Do(DC_EXEC, wagon->index, false, false, INVALID_CLIENT_ID);
					assert(ret.Succeeded());
					new_vehs[i] = nullptr;

					/* Revert the money subtraction when the vehicle was built.
					 * This value is different from the sell value, esp. because of refitting */
					cost.AddCost(-new_costs[i]);
				}
			}

			/* The new vehicle chain is constructed, now take over orders and everything... */
			if (cost.Succeeded()) cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));

			if (cost.Succeeded()) {
				/* Success ! */
				if ((flags & DC_EXEC) != 0 && new_head != old_head) {
					*chain = new_head;
					AI::NewEvent(old_head->owner, new ScriptEventVehicleAutoReplaced(old_head->index, new_head->index));
				}

				/* Transfer cargo of old vehicles and sell them */
				for (int i = 0; i < num_units; i++) {
					Vehicle *w = old_vehs[i];
					/* Is the vehicle again part of the new chain?
					 * Note: We cannot test 'new_vehs[i] != nullptr' as wagon removal might cause to remove both */
					if (w->First() == new_head) continue;

					if ((flags & DC_EXEC) != 0) TransferCargo(w, new_head, true);

					/* Sell the vehicle.
					 * Note: This might temporarily construct new trains, so use DC_AUTOREPLACE to prevent
					 *       it from failing due to engine limits. */
					cost.AddCost(Command<CMD_SELL_VEHICLE>::Do(flags | DC_AUTOREPLACE, w->index, false, false, INVALID_CLIENT_ID));
					if ((flags & DC_EXEC) != 0) {
						old_vehs[i] = nullptr;
						if (i == 0) old_head = nullptr;
					}
				}

				if ((flags & DC_EXEC) != 0) CheckCargoCapacity(new_head);
			}

			/* If we are not in DC_EXEC undo everything, i.e. rearrange old vehicles.
			 * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time.
			 * Note: The vehicle attach callback is disabled here :) */
			if ((flags & DC_EXEC) == 0) {
				/* Separate the head, so we can reattach the old vehicles */
				Train *second = Train::From(old_head)->GetNextUnit();
				if (second != nullptr) CmdMoveVehicle(second, nullptr, DC_EXEC | DC_AUTOREPLACE, true);

				assert(Train::From(old_head)->GetNextUnit() == nullptr);

				for (int i = num_units - 1; i > 0; i--) {
					[[maybe_unused]] CommandCost ret = CmdMoveVehicle(old_vehs[i], old_head, DC_EXEC | DC_AUTOREPLACE, false);
					assert(ret.Succeeded());
				}
			}
		}

		/* Finally undo buying of new vehicles */
		if ((flags & DC_EXEC) == 0) {
			for (int i = num_units - 1; i >= 0; i--) {
				if (new_vehs[i] != nullptr) {
					Command<CMD_SELL_VEHICLE>::Do(DC_EXEC, new_vehs[i]->index, false, false, INVALID_CLIENT_ID);
					new_vehs[i] = nullptr;
				}
			}
		}

		free(old_vehs);
		free(new_vehs);
		free(new_costs);
	} else {
		/* Build and refit replacement vehicle */
		Vehicle *new_head = nullptr;
		cost.AddCost(BuildReplacementVehicle(old_head, &new_head, true));

		/* Was a new vehicle constructed? */
		if (cost.Succeeded() && new_head != nullptr) {
			*nothing_to_do = false;

			/* The new vehicle is constructed, now take over orders and everything... */
			cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));

			if (cost.Succeeded()) {
				/* The new vehicle is constructed, now take over cargo */
				if ((flags & DC_EXEC) != 0) {
					TransferCargo(old_head, new_head, true);
					*chain = new_head;

					AI::NewEvent(old_head->owner, new ScriptEventVehicleAutoReplaced(old_head->index, new_head->index));
				}

				/* Sell the old vehicle */
				cost.AddCost(Command<CMD_SELL_VEHICLE>::Do(flags, old_head->index, false, false, INVALID_CLIENT_ID));
			}

			/* If we are not in DC_EXEC undo everything */
			if ((flags & DC_EXEC) == 0) {
				Command<CMD_SELL_VEHICLE>::Do(DC_EXEC, new_head->index, false, false, INVALID_CLIENT_ID);
			}
		}
	}

	return cost;
}

/**
 * Autoreplaces a vehicle
 * Trains are replaced as a whole chain, free wagons in depot are replaced on their own
 * @param flags type of operation
 * @param veh_id Index of vehicle
 * @return the cost of this operation or an error
 */
CommandCost CmdAutoreplaceVehicle(DoCommandFlag flags, VehicleID veh_id)
{
	Vehicle *v = Vehicle::GetIfValid(veh_id);
	if (v == nullptr) return CMD_ERROR;

	CommandCost ret = CheckOwnership(v->owner);
	if (ret.Failed()) return ret;

	if (v->vehstatus & VS_CRASHED) return CMD_ERROR;

	bool free_wagon = false;
	if (v->type == VEH_TRAIN) {
		Train *t = Train::From(v);
		if (t->IsArticulatedPart() || t->IsRearDualheaded()) return CMD_ERROR;
		free_wagon = !t->IsFrontEngine();
		if (free_wagon && t->First()->IsFrontEngine()) return CMD_ERROR;
	} else {
		if (!v->IsPrimaryVehicle()) return CMD_ERROR;
	}
	if (!v->IsChainInDepot()) return CMD_ERROR;

	const Company *c = Company::Get(_current_company);
	bool wagon_removal = c->settings.renew_keep_length;

	const Group *g = Group::GetIfValid(v->group_id);
	if (g != nullptr) wagon_removal = HasBit(g->flags, GroupFlags::GF_REPLACE_WAGON_REMOVAL);

	/* Test whether any replacement is set, before issuing a whole lot of commands that would end in nothing changed */
	Vehicle *w = v;
	bool any_replacements = false;
	while (w != nullptr) {
		EngineID e;
		CommandCost cost = GetNewEngineType(w, c, false, e);
		if (cost.Failed()) return cost;
		any_replacements |= (e != INVALID_ENGINE);
		w = (!free_wagon && w->type == VEH_TRAIN ? Train::From(w)->GetNextUnit() : nullptr);
	}

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, (Money)0);
	bool nothing_to_do = true;

	if (any_replacements) {
		bool was_stopped = free_wagon || ((v->vehstatus & VS_STOPPED) != 0);

		/* Stop the vehicle */
		if (!was_stopped) cost.AddCost(DoCmdStartStopVehicle(v, true));
		if (cost.Failed()) return cost;

		assert(free_wagon || v->IsStoppedInDepot());

		/* We have to construct the new vehicle chain to test whether it is valid.
		 * Vehicle construction needs random bits, so we have to save the random seeds
		 * to prevent desyncs and to replay newgrf callbacks during DC_EXEC */
		SavedRandomSeeds saved_seeds;
		SaveRandomSeeds(&saved_seeds);
		if (free_wagon) {
			cost.AddCost(ReplaceFreeUnit(&v, flags & ~DC_EXEC, &nothing_to_do));
		} else {
			cost.AddCost(ReplaceChain(&v, flags & ~DC_EXEC, wagon_removal, &nothing_to_do));
		}
		RestoreRandomSeeds(saved_seeds);

		if (cost.Succeeded() && (flags & DC_EXEC) != 0) {
			if (free_wagon) {
				ret = ReplaceFreeUnit(&v, flags, &nothing_to_do);
			} else {
				ret = ReplaceChain(&v, flags, wagon_removal, &nothing_to_do);
			}
			assert(ret.Succeeded() && ret.GetCost() == cost.GetCost());
		}

		/* Restart the vehicle */
		if (!was_stopped) cost.AddCost(DoCmdStartStopVehicle(v, false));
	}

	if (cost.Succeeded() && nothing_to_do) cost = CommandCost(STR_ERROR_AUTOREPLACE_NOTHING_TO_DO);
	return cost;
}

/**
 * Change engine renewal parameters
 * @param flags operation to perform
 * @param id_g engine group
 * @param old_engine_type old engine type
 * @param new_engine_type new engine type
 * @param when_old replace when engine gets old?
 * @return the cost of this operation or an error
 */
CommandCost CmdSetAutoReplace(DoCommandFlag flags, GroupID id_g, EngineID old_engine_type, EngineID new_engine_type, bool when_old)
{
	Company *c = Company::GetIfValid(_current_company);
	if (c == nullptr) return CMD_ERROR;

	CommandCost cost;

	if (Group::IsValidID(id_g) ? Group::Get(id_g)->owner != _current_company : !IsAllGroupID(id_g) && !IsDefaultGroupID(id_g)) return CMD_ERROR;
	if (!Engine::IsValidID(old_engine_type)) return CMD_ERROR;
	if (Group::IsValidID(id_g) && Group::Get(id_g)->vehicle_type != Engine::Get(old_engine_type)->type) return CMD_ERROR;

	if (new_engine_type != INVALID_ENGINE) {
		if (!Engine::IsValidID(new_engine_type)) return CMD_ERROR;
		if (!CheckAutoreplaceValidity(old_engine_type, new_engine_type, _current_company)) return CMD_ERROR;

		cost = AddEngineReplacementForCompany(c, old_engine_type, new_engine_type, id_g, when_old, flags);
	} else {
		cost = RemoveEngineReplacementForCompany(c, old_engine_type, id_g, flags);
	}

	if (flags & DC_EXEC) {
		GroupStatistics::UpdateAutoreplace(_current_company);
		if (IsLocalCompany()) SetWindowDirty(WC_REPLACE_VEHICLE, Engine::Get(old_engine_type)->type);

		const VehicleType vt = Engine::Get(old_engine_type)->type;
		SetWindowDirty(GetWindowClassForVehicleType(vt), VehicleListIdentifier(VL_GROUP_LIST, vt, _current_company).Pack());
	}
	if ((flags & DC_EXEC) && IsLocalCompany()) InvalidateAutoreplaceWindow(old_engine_type, id_g);

	return cost;
}