Files @ r16729:482bfc615285
Branch filter:

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

rubidium
(svn r21472) -Fix [FS#4298] (r21459-ish): make sure the query window is only opened once per parent window / callback.
   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
r5584:545d748cc681
r5584:545d748cc681
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r9111:983de9c5a848
r6432:3f618c3647c2
r5584:545d748cc681
r6134:aa2aee9f9144
r6453:b0b56773284a
r8224:194097dc7288
r8116:df67d3c5e4fd
r5584:545d748cc681
r8763:c2c776621d56
r8962:cfbdc736c8db
r8962:cfbdc736c8db
r8108:1d5bdeea7e20
r13176:254c27d58bd6
r6583:63b4cb964287
r8114:866ed489ed98
r8131:7a50db7be0ff
r8144:1432edd15267
r8157:cf41aa22cd09
r10208:ef8fcc3dc4ca
r8380:6b3d1e5a10ed
r8459:1ef090778f87
r10083:2e8288935c09
r9009:e21a5dd1e60e
r9490:5cf190d39c21
r12218:9b04ff1ad183
r11020:fc11b6252329
r14248:a9050881acd7
r15269:8b901e9e0694
r15350:38997da618b5
r5584:545d748cc681
r8264:d493cb51fe8a
r5584:545d748cc681
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r7948:c37d06109abc
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6432:3f618c3647c2
r6134:aa2aee9f9144
r5584:545d748cc681
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r14994:b24d36ab6c4f
r6134:aa2aee9f9144
r14815:e46af8c032ec
r5584:545d748cc681
r16552:2145cf9259fa
r11725:57bc99fdc1bc
r8471:0c8cd6eb92d6
r5584:545d748cc681
r16060:76d949a21564
r16060:76d949a21564
r5584:545d748cc681
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r11725:57bc99fdc1bc
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r14814:3d4abc0944bc
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r14814:3d4abc0944bc
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r16046:d66d1b4228b3
r5584:545d748cc681
r5584:545d748cc681
r9036:e33a0264e0c3
r15350:38997da618b5
r5584:545d748cc681
r12989:383937fd7eba
r12989:383937fd7eba
r5584:545d748cc681
r5584:545d748cc681
r15160:11bc0f456aa7
r5584:545d748cc681
r5584:545d748cc681
r16046:d66d1b4228b3
r5584:545d748cc681
r5584:545d748cc681
r8471:0c8cd6eb92d6
r8029:8fa304783822
r9718:c3fa0e5e369d
r8471:0c8cd6eb92d6
r9718:c3fa0e5e369d
r9718:c3fa0e5e369d
r9718:c3fa0e5e369d
r9718:c3fa0e5e369d
r9718:c3fa0e5e369d
r9718:c3fa0e5e369d
r15938:d72e39d2ec08
r15938:d72e39d2ec08
r15938:d72e39d2ec08
r15938:d72e39d2ec08
r9718:c3fa0e5e369d
r13298:ddbc752190f3
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r15938:d72e39d2ec08
r8029:8fa304783822
r15938:d72e39d2ec08
r15938:d72e39d2ec08
r8029:8fa304783822
r8029:8fa304783822
r11090:9276cea703d4
r5584:545d748cc681
r5584:545d748cc681
r14774:6075f6397e6f
r14774:6075f6397e6f
r14774:6075f6397e6f
r8520:d16bbcb96acc
r8520:d16bbcb96acc
r5584:545d748cc681
r8520:d16bbcb96acc
r8520:d16bbcb96acc
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r8520:d16bbcb96acc
r5584:545d748cc681
r5584:545d748cc681
r12991:ff20fa5b1c08
r5584:545d748cc681
r8495:3d4bceb612db
r8495:3d4bceb612db
r5584:545d748cc681
r5584:545d748cc681
r13476:add6db25d711
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r15080:d4393e44f839
r15080:d4393e44f839
r15080:d4393e44f839
r15080:d4393e44f839
r15080:d4393e44f839
r15079:f3d24662a0e5
r5584:545d748cc681
r15082:64380e9186f5
r15082:64380e9186f5
r6432:3f618c3647c2
r14815:e46af8c032ec
r14814:3d4abc0944bc
r15082:64380e9186f5
r5584:545d748cc681
r14815:e46af8c032ec
r6432:3f618c3647c2
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r15082:64380e9186f5
r15082:64380e9186f5
r15082:64380e9186f5
r15082:64380e9186f5
r15083:89759731a1a7
r15082:64380e9186f5
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r15082:64380e9186f5
r15082:64380e9186f5
r15082:64380e9186f5
r15082:64380e9186f5
r15083:89759731a1a7
r15082:64380e9186f5
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10207:a1fc2f2a33db
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8443:121222cb4f05
r8443:121222cb4f05
r5584:545d748cc681
r15084:158871f5a6b1
r5584:545d748cc681
r15082:64380e9186f5
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r15080:d4393e44f839
r15080:d4393e44f839
r15080:d4393e44f839
r15080:d4393e44f839
r15079:f3d24662a0e5
r5584:545d748cc681
r14774:6075f6397e6f
r14774:6075f6397e6f
r14774:6075f6397e6f
r14774:6075f6397e6f
r5584:545d748cc681
r14815:e46af8c032ec
r14815:e46af8c032ec
r6432:3f618c3647c2
r14775:2428bb19a19e
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r8443:121222cb4f05
r8443:121222cb4f05
r5584:545d748cc681
r5584:545d748cc681
r15084:158871f5a6b1
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6432:3f618c3647c2
r5584:545d748cc681
r5584:545d748cc681
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r8413:49df1f427ffc
r11725:57bc99fdc1bc
r8386:86c333e278d5
r8386:86c333e278d5
r11725:57bc99fdc1bc
r8386:86c333e278d5
r15079:f3d24662a0e5
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5584:545d748cc681
r6432:3f618c3647c2
r5584:545d748cc681
r15038:4f765acd05a0
r13057:58af81fcdcf8
r13057:58af81fcdcf8
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r15038:4f765acd05a0
r15038:4f765acd05a0
r8360:4a4998989c92
r6286:df343885e41c
r15038:4f765acd05a0
r5584:545d748cc681
r14162:e1a7500ad103
r5584:545d748cc681
r5584:545d748cc681
r14162:e1a7500ad103
r5584:545d748cc681
r14815:e46af8c032ec
r14162:e1a7500ad103
r6943:a727ca1f1062
r5584:545d748cc681
r8360:4a4998989c92
r15038:4f765acd05a0
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r15038:4f765acd05a0
r5584:545d748cc681
r16045:4e872bd29db8
r14304:dc9cb5b9e881
r6950:1a54b1afb12a
r5584:545d748cc681
r5584:545d748cc681
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r15616:f386c05f9d59
r15616:f386c05f9d59
r15038:4f765acd05a0
r15038:4f765acd05a0
r15038:4f765acd05a0
r5584:545d748cc681
r5584:545d748cc681
r8443:121222cb4f05
r5584:545d748cc681
r5584:545d748cc681
r15084:158871f5a6b1
r12519:e52fcaadf579
r5584:545d748cc681
r6950:1a54b1afb12a
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11090:9276cea703d4
r5584:545d748cc681
r5584:545d748cc681
r14721:f3e02434b6fb
r11725:57bc99fdc1bc
r5584:545d748cc681
r15084:158871f5a6b1
r10855:5a3c2f38f98e
r10855:5a3c2f38f98e
r10855:5a3c2f38f98e
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r7509:c5114490e828
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r7509:c5114490e828
r14774:6075f6397e6f
r14774:6075f6397e6f
r14774:6075f6397e6f
r14774:6075f6397e6f
r5584:545d748cc681
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r15084:158871f5a6b1
r15084:158871f5a6b1
r14721:f3e02434b6fb
r5584:545d748cc681
r6181:1cf3114368df
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r14721:f3e02434b6fb
r14721:f3e02434b6fb
r5584:545d748cc681
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8443:121222cb4f05
r8413:49df1f427ffc
r13476:add6db25d711
r5584:545d748cc681
r13476:add6db25d711
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6181:1cf3114368df
r15079:f3d24662a0e5
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11725:57bc99fdc1bc
r10207:a1fc2f2a33db
r6432:3f618c3647c2
r15079:f3d24662a0e5
r5584:545d748cc681
r5584:545d748cc681
r6181:1cf3114368df
r11725:57bc99fdc1bc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r9496:d6293d3ad201
r8441:c2fa18ebb72e
r5584:545d748cc681
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r11941:8901ca1bc641
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r9721:651ebc1cbf61
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r16038:9c4e6a0b8700
r9722:b0d2645a38ce
r9721:651ebc1cbf61
r9721:651ebc1cbf61
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r15933:39e6324db57a
r9722:b0d2645a38ce
r9722:b0d2645a38ce
r15942:04a4b4326c6c
r15942:04a4b4326c6c
r9496:d6293d3ad201
r9722:b0d2645a38ce
r7507:0f91ef98d84a
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r5584:545d748cc681
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r8441:c2fa18ebb72e
r5584:545d748cc681
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r5584:545d748cc681
r6432:3f618c3647c2
r5584:545d748cc681
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r5584:545d748cc681
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r5584:545d748cc681
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r5584:545d748cc681
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8471:0c8cd6eb92d6
r8496:af020be188ec
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r8471:0c8cd6eb92d6
r8360:4a4998989c92
r8496:af020be188ec
r8360:4a4998989c92
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15677:fa81b10db8cc
r8471:0c8cd6eb92d6
r15677:fa81b10db8cc
r8360:4a4998989c92
r8360:4a4998989c92
r6248:b940b09d7ab8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6248:b940b09d7ab8
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15677:fa81b10db8cc
r5584:545d748cc681
r15675:2e01fc5e63aa
r8806:1fc0d9e1c2bf
r8806:1fc0d9e1c2bf
r5584:545d748cc681
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r5668:e62c2fbafb7b
r11182:3538f6e8d64e
r11182:3538f6e8d64e
r7849:cfd99cb69695
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15676:7a77488f2e8a
r15675:2e01fc5e63aa
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15676:7a77488f2e8a
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15677:fa81b10db8cc
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15677:fa81b10db8cc
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r8496:af020be188ec
r8360:4a4998989c92
r8360:4a4998989c92
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r8360:4a4998989c92
r15676:7a77488f2e8a
r8360:4a4998989c92
r8360:4a4998989c92
r8430:072605def7ec
r8430:072605def7ec
r8430:072605def7ec
r8430:072605def7ec
r8430:072605def7ec
r8430:072605def7ec
r8430:072605def7ec
r8360:4a4998989c92
r15676:7a77488f2e8a
r15677:fa81b10db8cc
r15676:7a77488f2e8a
r8360:4a4998989c92
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15677:fa81b10db8cc
r15676:7a77488f2e8a
r8360:4a4998989c92
r15676:7a77488f2e8a
r15677:fa81b10db8cc
r8360:4a4998989c92
r8360:4a4998989c92
r8360:4a4998989c92
r15677:fa81b10db8cc
r8360:4a4998989c92
r8430:072605def7ec
r15677:fa81b10db8cc
r8360:4a4998989c92
r8360:4a4998989c92
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r13175:ef1f91f8caa1
r13175:ef1f91f8caa1
r8496:af020be188ec
r8496:af020be188ec
r8496:af020be188ec
r8496:af020be188ec
r9718:c3fa0e5e369d
r8496:af020be188ec
r8496:af020be188ec
r8496:af020be188ec
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6181:1cf3114368df
r8496:af020be188ec
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8164:c60d7059d0da
r8380:6b3d1e5a10ed
r5584:545d748cc681
r15608:7b580ec7448a
r15608:7b580ec7448a
r5584:545d748cc681
r15675:2e01fc5e63aa
r15675:2e01fc5e63aa
r15608:7b580ec7448a
r5584:545d748cc681
r6181:1cf3114368df
r15675:2e01fc5e63aa
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5668:e62c2fbafb7b
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11085:c87a330fb4c2
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5587:034e5e185dc2
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7335:93bf5f4b6ce4
r5584:545d748cc681
r7335:93bf5f4b6ce4
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6181:1cf3114368df
r9517:0ec6289f6a02
r12622:202e83a6cee7
r12622:202e83a6cee7
r12622:202e83a6cee7
r12553:f443d44dbd97
r5584:545d748cc681
r5584:545d748cc681
r12622:202e83a6cee7
r12622:202e83a6cee7
r15350:38997da618b5
r15350:38997da618b5
r15350:38997da618b5
r15350:38997da618b5
r12553:f443d44dbd97
r5584:545d748cc681
r5584:545d748cc681
r9322:3f83b0034795
r5584:545d748cc681
r5584:545d748cc681
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r10083:2e8288935c09
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r10083:2e8288935c09
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r15835:f3f0a3396e68
r10083:2e8288935c09
r10083:2e8288935c09
r5584:545d748cc681
r5940:476169f4235d
r5940:476169f4235d
r5940:476169f4235d
r5940:476169f4235d
r5940:476169f4235d
r10083:2e8288935c09
r5940:476169f4235d
r10083:2e8288935c09
r10083:2e8288935c09
r14296:8d95af9907fc
r12218:9b04ff1ad183
r14611:79a9ea376bde
r14611:79a9ea376bde
r6906:09e2c5479599
r6906:09e2c5479599
r6906:09e2c5479599
r10083:2e8288935c09
r6906:09e2c5479599
r6906:09e2c5479599
r8014:2195f93bc267
r9413:fcf267325763
r12218:9b04ff1ad183
r8014:2195f93bc267
r14160:24d7cfd54d1c
r8014:2195f93bc267
r10083:2e8288935c09
r8014:2195f93bc267
r12519:e52fcaadf579
r8014:2195f93bc267
r10083:2e8288935c09
r8014:2195f93bc267
r8014:2195f93bc267
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r10083:2e8288935c09
r5940:476169f4235d
r5940:476169f4235d
r10083:2e8288935c09
r5940:476169f4235d
r10083:2e8288935c09
r10083:2e8288935c09
r5940:476169f4235d
r5940:476169f4235d
r7731:91af78ddd969
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r15450:25ca1fe6bdae
r8380:6b3d1e5a10ed
r9718:c3fa0e5e369d
r8459:1ef090778f87
r9718:c3fa0e5e369d
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8413:49df1f427ffc
r8380:6b3d1e5a10ed
r15933:39e6324db57a
r15933:39e6324db57a
r15933:39e6324db57a
r15942:04a4b4326c6c
r15933:39e6324db57a
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8380:6b3d1e5a10ed
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r10855:5a3c2f38f98e
r8380:6b3d1e5a10ed
r8684:85f3376eb69e
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r15282:8e9c51163c93
r8380:6b3d1e5a10ed
r8459:1ef090778f87
r8459:1ef090778f87
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r11941:8901ca1bc641
r10083:2e8288935c09
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r15616:f386c05f9d59
r15616:f386c05f9d59
r8380:6b3d1e5a10ed
r14304:dc9cb5b9e881
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r10083:2e8288935c09
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r14304:dc9cb5b9e881
r13298:ddbc752190f3
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8443:121222cb4f05
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r15269:8b901e9e0694
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r15282:8e9c51163c93
r8380:6b3d1e5a10ed
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r11941:8901ca1bc641
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r8459:1ef090778f87
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r14304:dc9cb5b9e881
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8414:53905e5b5cf3
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r15269:8b901e9e0694
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r7731:91af78ddd969
r7771:07da146f39f8
r7731:91af78ddd969
r7731:91af78ddd969
r7731:91af78ddd969
r5584:545d748cc681
r5584:545d748cc681
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8684:85f3376eb69e
r8684:85f3376eb69e
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8801:980f66968b1a
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r5584:545d748cc681
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r5584:545d748cc681
r8380:6b3d1e5a10ed
r8801:980f66968b1a
r8380:6b3d1e5a10ed
r15149:3302fb46615e
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r5584:545d748cc681
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r5584:545d748cc681
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r5584:545d748cc681
r8380:6b3d1e5a10ed
r7731:91af78ddd969
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r5584:545d748cc681
r14815:e46af8c032ec
r14815:e46af8c032ec
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r13298:ddbc752190f3
r8380:6b3d1e5a10ed
r5584:545d748cc681
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r5584:545d748cc681
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r15149:3302fb46615e
r8380:6b3d1e5a10ed
r8801:980f66968b1a
r8413:49df1f427ffc
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r8380:6b3d1e5a10ed
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8616:656db5986c9e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8471:0c8cd6eb92d6
r6181:1cf3114368df
r9224:0340c9af9930
r6181:1cf3114368df
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6432:3f618c3647c2
r5584:545d748cc681
r5584:545d748cc681
r8616:656db5986c9e
r5584:545d748cc681
r5584:545d748cc681
r10532:23a12232250b
r5584:545d748cc681
r6181:1cf3114368df
r15867:ecad3e587c06
r10532:23a12232250b
r5584:545d748cc681
r10532:23a12232250b
r5584:545d748cc681
r5584:545d748cc681
r10207:a1fc2f2a33db
r5584:545d748cc681
r10207:a1fc2f2a33db
r5584:545d748cc681
r10207:a1fc2f2a33db
r10207:a1fc2f2a33db
r8520:d16bbcb96acc
r5584:545d748cc681
r8520:d16bbcb96acc
r8520:d16bbcb96acc
r8520:d16bbcb96acc
r8520:d16bbcb96acc
r8520:d16bbcb96acc
r8520:d16bbcb96acc
r10207:a1fc2f2a33db
r5584:545d748cc681
r5584:545d748cc681
r8119:8fdb3a371896
r5584:545d748cc681
r5991:254bad51c6b2
r5584:545d748cc681
r5584:545d748cc681
r11090:9276cea703d4
r7494:2e43e3339051
r7494:2e43e3339051
r12622:202e83a6cee7
r7494:2e43e3339051
r7494:2e43e3339051
r7494:2e43e3339051
r7494:2e43e3339051
r5584:545d748cc681
r5587:034e5e185dc2
r11363:6906c490a00e
r11363:6906c490a00e
r11363:6906c490a00e
r12235:f6faf5ffa926
r11363:6906c490a00e
r11363:6906c490a00e
r11363:6906c490a00e
r12235:f6faf5ffa926
r11363:6906c490a00e
r11363:6906c490a00e
r12248:7acc3688a3f0
r11363:6906c490a00e
r11363:6906c490a00e
r11363:6906c490a00e
r5584:545d748cc681
/* $Id$ */

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

/** @file water_cmd.cpp Handling of water tiles. */

#include "stdafx.h"
#include "cmd_helper.h"
#include "landscape.h"
#include "viewport_func.h"
#include "command_func.h"
#include "town.h"
#include "news_func.h"
#include "depot_base.h"
#include "depot_func.h"
#include "water.h"
#include "industry_map.h"
#include "newgrf_canal.h"
#include "strings_func.h"
#include "functions.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "company_func.h"
#include "clear_map.h"
#include "tree_map.h"
#include "aircraft.h"
#include "effectvehicle_func.h"
#include "tunnelbridge_map.h"
#include "station_base.h"
#include "ai/ai.hpp"
#include "core/random_func.hpp"
#include "core/backup_type.hpp"
#include "date_func.h"

#include "table/strings.h"

/**
 * Describes from which directions a specific slope can be flooded (if the tile is floodable at all).
 */
static const uint8 _flood_from_dirs[] = {
	(1 << DIR_NW) | (1 << DIR_SW) | (1 << DIR_SE) | (1 << DIR_NE), // SLOPE_FLAT
	(1 << DIR_NE) | (1 << DIR_SE),                                 // SLOPE_W
	(1 << DIR_NW) | (1 << DIR_NE),                                 // SLOPE_S
	(1 << DIR_NE),                                                 // SLOPE_SW
	(1 << DIR_NW) | (1 << DIR_SW),                                 // SLOPE_E
	0,                                                             // SLOPE_EW
	(1 << DIR_NW),                                                 // SLOPE_SE
	(1 << DIR_N ) | (1 << DIR_NW) | (1 << DIR_NE),                 // SLOPE_WSE, SLOPE_STEEP_S
	(1 << DIR_SW) | (1 << DIR_SE),                                 // SLOPE_N
	(1 << DIR_SE),                                                 // SLOPE_NW
	0,                                                             // SLOPE_NS
	(1 << DIR_E ) | (1 << DIR_NE) | (1 << DIR_SE),                 // SLOPE_NWS, SLOPE_STEEP_W
	(1 << DIR_SW),                                                 // SLOPE_NE
	(1 << DIR_S ) | (1 << DIR_SW) | (1 << DIR_SE),                 // SLOPE_ENW, SLOPE_STEEP_N
	(1 << DIR_W ) | (1 << DIR_SW) | (1 << DIR_NW),                 // SLOPE_SEN, SLOPE_STEEP_E
};

/**
 * Marks tile dirty if it is a canal or river tile.
 * Called to avoid glitches when flooding tiles next to canal tile.
 *
 * @param tile tile to check
 */
static inline void MarkTileDirtyIfCanalOrRiver(TileIndex tile)
{
	if (IsTileType(tile, MP_WATER) && (IsCanal(tile) || IsRiver(tile))) MarkTileDirtyByTile(tile);
}

/**
 * Marks the tiles around a tile as dirty, if they are canals or rivers.
 *
 * @param tile The center of the tile where all other tiles are marked as dirty
 * @ingroup dirty
 */
static void MarkCanalsAndRiversAroundDirty(TileIndex tile)
{
	for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
		MarkTileDirtyIfCanalOrRiver(tile + TileOffsByDir(dir));
	}
}


/**
 * Build a ship depot.
 * @param tile tile where ship depot is built
 * @param flags type of operation
 * @param p1 bit 0 depot orientation (Axis)
 * @param p2 unused
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdBuildShipDepot(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	Axis axis = Extract<Axis, 0, 1>(p1);

	TileIndex tile2 = tile + (axis == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));

	if (!HasTileWaterGround(tile) || !HasTileWaterGround(tile2)) {
		return_cmd_error(STR_ERROR_MUST_BE_BUILT_ON_WATER);
	}

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

	if (GetTileSlope(tile, NULL) != SLOPE_FLAT || GetTileSlope(tile2, NULL) != SLOPE_FLAT) {
		/* Prevent depots on rapids */
		return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
	}

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

	WaterClass wc1 = GetWaterClass(tile);
	WaterClass wc2 = GetWaterClass(tile2);
	CommandCost cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_DEPOT_SHIP]);

	bool add_cost = !IsWaterTile(tile);
	CommandCost ret = DoCommand(tile, 0, 0, flags | DC_AUTO, CMD_LANDSCAPE_CLEAR);
	if (ret.Failed()) return ret;
	if (add_cost) {
		cost.AddCost(ret);
	}
	add_cost = !IsWaterTile(tile2);
	ret = DoCommand(tile2, 0, 0, flags | DC_AUTO, CMD_LANDSCAPE_CLEAR);
	if (ret.Failed()) return ret;
	if (add_cost) {
		cost.AddCost(ret);
	}

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

		MakeShipDepot(tile,  _current_company, depot->index, DEPOT_NORTH, axis, wc1);
		MakeShipDepot(tile2, _current_company, depot->index, DEPOT_SOUTH, axis, wc2);
		MarkTileDirtyByTile(tile);
		MarkTileDirtyByTile(tile2);
		MakeDefaultName(depot);
	}

	return cost;
}

void MakeWaterKeepingClass(TileIndex tile, Owner o)
{
	WaterClass wc = GetWaterClass(tile);

	/* Autoslope might turn an originally canal or river tile into land */
	uint z;
	if (GetTileSlope(tile, &z) != SLOPE_FLAT) wc = WATER_CLASS_INVALID;

	if (wc == WATER_CLASS_SEA && z > 0) wc = WATER_CLASS_CANAL;

	/* Zero map array and terminate animation */
	DoClearSquare(tile);

	/* Maybe change to water */
	switch (wc) {
		case WATER_CLASS_SEA:   MakeSea(tile);                break;
		case WATER_CLASS_CANAL: MakeCanal(tile, o, Random()); break;
		case WATER_CLASS_RIVER: MakeRiver(tile, Random());    break;
		default: break;
	}

	MarkTileDirtyByTile(tile);
}

static CommandCost RemoveShipDepot(TileIndex tile, DoCommandFlag flags)
{
	if (!IsShipDepot(tile)) return CMD_ERROR;

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

	TileIndex tile2 = GetOtherShipDepotTile(tile);

	/* do not check for ship on tile when company goes bankrupt */
	if (!(flags & DC_BANKRUPT)) {
		CommandCost ret = EnsureNoVehicleOnGround(tile);
		if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile2);
		if (ret.Failed()) return ret;
	}

	if (flags & DC_EXEC) {
		delete Depot::GetByTile(tile);

		MakeWaterKeepingClass(tile,  GetTileOwner(tile));
		MakeWaterKeepingClass(tile2, GetTileOwner(tile2));
	}

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

/**
 * Builds a lock.
 * @param tile Central tile of the lock.
 * @param dir Uphill direction.
 * @param flags Operation to perform.
 * @return The cost in case of success, or an error code if it failed.
 */
static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlag flags)
{
	CommandCost cost(EXPENSES_CONSTRUCTION);

	/* middle tile */
	CommandCost ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
	if (ret.Failed()) return ret;
	cost.AddCost(ret);

	int delta = TileOffsByDiagDir(dir);
	/* lower tile */
	WaterClass wc_lower = IsWaterTile(tile - delta) ? GetWaterClass(tile - delta) : WATER_CLASS_CANAL;

	if (!IsWaterTile(tile - delta)) {
		ret = DoCommand(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
		if (ret.Failed()) return ret;
		cost.AddCost(ret);
		cost.AddCost(_price[PR_CLEAR_WATER]);
	}
	if (GetTileSlope(tile - delta, NULL) != SLOPE_FLAT) {
		return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
	}

	/* upper tile */
	WaterClass wc_upper = IsWaterTile(tile + delta) ? GetWaterClass(tile + delta) : WATER_CLASS_CANAL;

	if (!IsWaterTile(tile + delta)) {
		ret = DoCommand(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
		if (ret.Failed()) return ret;
		cost.AddCost(ret);
		cost.AddCost(_price[PR_CLEAR_WATER]);
	}
	if (GetTileSlope(tile + delta, NULL) != SLOPE_FLAT) {
		return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
	}

	if ((MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) ||
	    (MayHaveBridgeAbove(tile - delta) && IsBridgeAbove(tile - delta)) ||
	    (MayHaveBridgeAbove(tile + delta) && IsBridgeAbove(tile + delta))) {
		return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
	}

	if (flags & DC_EXEC) {
		MakeLock(tile, _current_company, dir, wc_lower, wc_upper);
		MarkTileDirtyByTile(tile);
		MarkTileDirtyByTile(tile - delta);
		MarkTileDirtyByTile(tile + delta);
		MarkCanalsAndRiversAroundDirty(tile - delta);
		MarkCanalsAndRiversAroundDirty(tile + delta);
	}
	cost.AddCost(_price[PR_BUILD_LOCK]);

	return cost;
}

/**
 * Remove a lock.
 * @param tile Central tile of the lock.
 * @param flags Operation to perform.
 * @return The cost in case of success, or an error code if it failed.
 */
static CommandCost RemoveLock(TileIndex tile, DoCommandFlag flags)
{
	if (GetTileOwner(tile) != OWNER_NONE) {
		CommandCost ret = CheckTileOwnership(tile);
		if (ret.Failed()) return ret;
	}

	TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));

	/* make sure no vehicle is on the tile. */
	CommandCost ret = EnsureNoVehicleOnGround(tile);
	if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile + delta);
	if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile - delta);
	if (ret.Failed()) return ret;

	if (flags & DC_EXEC) {
		DoClearSquare(tile);
		MakeWaterKeepingClass(tile + delta, GetTileOwner(tile));
		MakeWaterKeepingClass(tile - delta, GetTileOwner(tile));
		MarkCanalsAndRiversAroundDirty(tile - delta);
		MarkCanalsAndRiversAroundDirty(tile + delta);
	}

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

/**
 * Builds a lock.
 * @param tile tile where to place the lock
 * @param flags type of operation
 * @param p1 unused
 * @param p2 unused
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdBuildLock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile, NULL));
	if (dir == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);

	/* Disallow building of locks on river rapids */
	if (IsWaterTile(tile)) return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

	return DoBuildLock(tile, dir, flags);
}

/**
 * Build a piece of canal.
 * @param tile end tile of stretch-dragging
 * @param flags type of operation
 * @param p1 start tile of stretch-dragging
 * @param p2 waterclass to build. sea and river can only be built in scenario editor
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdBuildCanal(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
	WaterClass wc = Extract<WaterClass, 0, 2>(p2);
	if (p1 >= MapSize() || wc == WATER_CLASS_INVALID) return CMD_ERROR;

	/* Outside of the editor you can only build canals, not oceans */
	if (wc != WATER_CLASS_CANAL && _game_mode != GM_EDITOR) return CMD_ERROR;

	TileArea ta(tile, p1);

	/* Outside the editor you can only drag canals, and not areas */
	if (_game_mode != GM_EDITOR && ta.w != 1 && ta.h != 1) return CMD_ERROR;

	CommandCost cost(EXPENSES_CONSTRUCTION);
	TILE_AREA_LOOP(tile, ta) {
		CommandCost ret;

		Slope slope = GetTileSlope(tile, NULL);
		if (slope != SLOPE_FLAT && (wc != WATER_CLASS_RIVER || !IsInclinedSlope(slope))) {
			return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
		}

		/* can't make water of water! */
		if (IsTileType(tile, MP_WATER) && (!IsTileOwner(tile, OWNER_WATER) || wc == WATER_CLASS_SEA)) continue;

		ret = DoCommand(tile, 0, 0, flags | DC_FORCE_CLEAR_TILE, CMD_LANDSCAPE_CLEAR);
		if (ret.Failed()) return ret;
		cost.AddCost(ret);

		if (flags & DC_EXEC) {
			switch (wc) {
				case WATER_CLASS_RIVER:
					MakeRiver(tile, Random());
					break;

				case WATER_CLASS_SEA:
					if (TileHeight(tile) == 0) {
						MakeSea(tile);
						break;
					}
					/* FALL THROUGH */

				default:
					MakeCanal(tile, _current_company, Random());
					break;
			}
			MarkTileDirtyByTile(tile);
			MarkCanalsAndRiversAroundDirty(tile);
		}

		cost.AddCost(_price[PR_BUILD_CANAL]);
	}

	if (cost.GetCost() == 0) {
		return_cmd_error(STR_ERROR_ALREADY_BUILT);
	} else {
		return cost;
	}
}

static CommandCost ClearTile_Water(TileIndex tile, DoCommandFlag flags)
{
	switch (GetWaterTileType(tile)) {
		case WATER_TILE_CLEAR: {
			if (flags & DC_NO_WATER) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);

			Money base_cost = IsCanal(tile) ? _price[PR_CLEAR_CANAL] : _price[PR_CLEAR_WATER];
			/* Make sure freeform edges are allowed or it's not an edge tile. */
			if (!_settings_game.construction.freeform_edges && (!IsInsideMM(TileX(tile), 1, MapMaxX() - 1) ||
					!IsInsideMM(TileY(tile), 1, MapMaxY() - 1))) {
				return_cmd_error(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP);
			}

			/* Make sure no vehicle is on the tile */
			CommandCost ret = EnsureNoVehicleOnGround(tile);
			if (ret.Failed()) return ret;

			if (GetTileOwner(tile) != OWNER_WATER && GetTileOwner(tile) != OWNER_NONE) {
				CommandCost ret = CheckTileOwnership(tile);
				if (ret.Failed()) return ret;
			}

			if (flags & DC_EXEC) {
				DoClearSquare(tile);
				MarkCanalsAndRiversAroundDirty(tile);
			}

			return CommandCost(EXPENSES_CONSTRUCTION, base_cost);
		}

		case WATER_TILE_COAST: {
			Slope slope = GetTileSlope(tile, NULL);

			/* Make sure no vehicle is on the tile */
			CommandCost ret = EnsureNoVehicleOnGround(tile);
			if (ret.Failed()) return ret;

			if (flags & DC_EXEC) {
				DoClearSquare(tile);
				MarkCanalsAndRiversAroundDirty(tile);
			}
			if (IsSlopeWithOneCornerRaised(slope)) {
				return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_WATER]);
			} else {
				return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_ROUGH]);
			}
		}

		case WATER_TILE_LOCK: {
			static const TileIndexDiffC _lock_tomiddle_offs[] = {
				{ 0,  0}, {0,  0}, { 0, 0}, {0,  0}, // middle
				{-1,  0}, {0,  1}, { 1, 0}, {0, -1}, // lower
				{ 1,  0}, {0, -1}, {-1, 0}, {0,  1}, // upper
			};

			if (flags & DC_AUTO) return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
			if (_current_company == OWNER_WATER) return CMD_ERROR;
			/* move to the middle tile.. */
			return RemoveLock(tile + ToTileIndexDiff(_lock_tomiddle_offs[GetSection(tile)]), flags);
		}

		case WATER_TILE_DEPOT:
			if (flags & DC_AUTO) return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
			return RemoveShipDepot(tile, flags);

		default:
			NOT_REACHED();
	}
}

/**
 * return true if a tile is a water tile wrt. a certain direction.
 *
 * @param tile The tile of interest.
 * @param from The direction of interest.
 * @return true iff the tile is water in the view of 'from'.
 *
 */
static bool IsWateredTile(TileIndex tile, Direction from)
{
	switch (GetTileType(tile)) {
		case MP_WATER:
			switch (GetWaterTileType(tile)) {
				default: NOT_REACHED();
				case WATER_TILE_DEPOT: case WATER_TILE_CLEAR: return true;
				case WATER_TILE_LOCK: return DiagDirToAxis(GetLockDirection(tile)) == DiagDirToAxis(DirToDiagDir(from));

				case WATER_TILE_COAST:
					switch (GetTileSlope(tile, NULL)) {
						case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);
						case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
						case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
						case SLOPE_N: return (from == DIR_SW) || (from == DIR_S) || (from == DIR_SE);
						default: return false;
					}
			}

		case MP_RAILWAY:
			if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
				assert(IsPlainRail(tile));
				switch (GetTileSlope(tile, NULL)) {
					case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);
					case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
					case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
					case SLOPE_N: return (from == DIR_SW) || (from == DIR_S) || (from == DIR_SE);
					default: return false;
				}
			}
			return false;

		case MP_STATION:
			if (IsOilRig(tile)) {
				/* Do not draw waterborders inside of industries.
				 * Note: There is no easy way to detect the industry of an oilrig tile. */
				TileIndex src_tile = tile + TileOffsByDir(from);
				if ((IsTileType(src_tile, MP_STATION) && IsOilRig(src_tile)) ||
				    (IsTileType(src_tile, MP_INDUSTRY))) return true;

				return IsTileOnWater(tile);
			}
			return (IsDock(tile) && GetTileSlope(tile, NULL) == SLOPE_FLAT) || IsBuoy(tile);

		case MP_INDUSTRY: {
			/* Do not draw waterborders inside of industries.
			 * Note: There is no easy way to detect the industry of an oilrig tile. */
			TileIndex src_tile = tile + TileOffsByDir(from);
			if ((IsTileType(src_tile, MP_STATION) && IsOilRig(src_tile)) ||
			    (IsTileType(src_tile, MP_INDUSTRY) && GetIndustryIndex(src_tile) == GetIndustryIndex(tile))) return true;

			return IsTileOnWater(tile);
		}

		case MP_OBJECT: return IsTileOnWater(tile);

		case MP_TUNNELBRIDGE: return GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER && ReverseDiagDir(GetTunnelBridgeDirection(tile)) == DirToDiagDir(from);

		default:          return false;
	}
}

/**
 * Draw a water sprite, potentially with a NewGRF-modified sprite offset.
 * @param base    Sprite base.
 * @param offset  Sprite offset.
 * @param feature The type of sprite that is drawn.
 * @param tile    Tile index to draw.
 */
static void DrawWaterSprite(SpriteID base, uint offset, CanalFeature feature, TileIndex tile)
{
	if (base != SPR_FLAT_WATER_TILE) {
		/* Only call offset callback if the sprite is NewGRF-provided. */
		offset = GetCanalSpriteOffset(feature, tile, offset);
	}
	DrawGroundSprite(base + offset, PAL_NONE);
}

/**
 * Draw canal or river edges.
 * @param canal  True if canal edges should be drawn, false for river edges.
 * @param offset Sprite offset.
 * @param tile   Tile to draw.
 */
static void DrawWaterEdges(bool canal, uint offset, TileIndex tile)
{
	CanalFeature feature;
	SpriteID base = 0;
	if (canal) {
		feature = CF_DIKES;
		base = GetCanalSprite(CF_DIKES, tile);
		if (base == 0) base = SPR_CANAL_DIKES_BASE;
	} else {
		feature = CF_RIVER_EDGE;
		base = GetCanalSprite(CF_RIVER_EDGE, tile);
		if (base == 0) return; // Don't draw if no sprites provided.
	}

	uint wa;

	/* determine the edges around with water. */
	wa  = IsWateredTile(TILE_ADDXY(tile, -1,  0), DIR_SW) << 0;
	wa += IsWateredTile(TILE_ADDXY(tile,  0,  1), DIR_NW) << 1;
	wa += IsWateredTile(TILE_ADDXY(tile,  1,  0), DIR_NE) << 2;
	wa += IsWateredTile(TILE_ADDXY(tile,  0, -1), DIR_SE) << 3;

	if (!(wa & 1)) DrawWaterSprite(base, offset,     feature, tile);
	if (!(wa & 2)) DrawWaterSprite(base, offset + 1, feature, tile);
	if (!(wa & 4)) DrawWaterSprite(base, offset + 2, feature, tile);
	if (!(wa & 8)) DrawWaterSprite(base, offset + 3, feature, tile);

	/* right corner */
	switch (wa & 0x03) {
		case 0: DrawWaterSprite(base, offset + 4, feature, tile); break;
		case 3: if (!IsWateredTile(TILE_ADDXY(tile, -1, 1), DIR_W)) DrawWaterSprite(base, offset + 8, feature, tile); break;
	}

	/* bottom corner */
	switch (wa & 0x06) {
		case 0: DrawWaterSprite(base, offset + 5, feature, tile); break;
		case 6: if (!IsWateredTile(TILE_ADDXY(tile, 1, 1), DIR_N)) DrawWaterSprite(base, offset + 9, feature, tile); break;
	}

	/* left corner */
	switch (wa & 0x0C) {
		case  0: DrawWaterSprite(base, offset + 6, feature, tile); break;
		case 12: if (!IsWateredTile(TILE_ADDXY(tile, 1, -1), DIR_E)) DrawWaterSprite(base, offset + 10, feature, tile); break;
	}

	/* upper corner */
	switch (wa & 0x09) {
		case 0: DrawWaterSprite(base, offset + 7, feature, tile); break;
		case 9: if (!IsWateredTile(TILE_ADDXY(tile, -1, -1), DIR_S)) DrawWaterSprite(base, offset + 11, feature, tile); break;
	}
}

/** Draw a plain sea water tile with no edges */
static void DrawSeaWater(TileIndex tile)
{
	DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
}

/** draw a canal styled water tile with dikes around */
static void DrawCanalWater(TileIndex tile)
{
	SpriteID image = SPR_FLAT_WATER_TILE;
	if (HasBit(_water_feature[CF_WATERSLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
		/* First water slope sprite is flat water. */
		image = GetCanalSprite(CF_WATERSLOPE, tile);
		if (image == 0) image = SPR_FLAT_WATER_TILE;
	}
	DrawWaterSprite(image, 0, CF_WATERSLOPE, tile);

	DrawWaterEdges(true, 0, tile);
}

struct LocksDrawTileStruct {
	int8 delta_x, delta_y, delta_z;
	byte width, height, depth;
	SpriteID image;
};

#include "table/water_land.h"

/**
 * Draw a build sprite sequence for water tiles.
 * If buildings are invisible, nothing will be drawn.
 * @param ti      Tile info.
 * @param wdts    Sprite sequence to draw.
 * @param base    Base sprite.
 * @param offset  Additional sprite offset.
 * @param palette Palette to use.
 */
static void DrawWaterTileStruct(const TileInfo *ti, const WaterDrawTileStruct *wdts, SpriteID base, uint offset, PaletteID palette, CanalFeature feature)
{
	/* Don't draw if buildings are invisible. */
	if (IsInvisibilitySet(TO_BUILDINGS)) return;

	for (; wdts->delta_x != 0x80; wdts++) {
		uint tile_offs = offset + wdts->image;
		if (feature < CF_END) tile_offs = GetCanalSpriteOffset(feature, ti->tile, tile_offs);
		AddSortableSpriteToDraw(base + tile_offs, palette,
			ti->x + wdts->delta_x, ti->y + wdts->delta_y,
			wdts->size_x, wdts->size_y,
			wdts->size_z, ti->z + wdts->delta_z,
			IsTransparencySet(TO_BUILDINGS));
	}
}

/** Draw a lock tile. */
static void DrawWaterLock(const TileInfo *ti)
{
	const WaterDrawTileStruct *wdts = _lock_display_seq[GetSection(ti->tile)];

	/* Draw ground sprite. */
	SpriteID image = wdts++->image;

	SpriteID water_base = GetCanalSprite(CF_WATERSLOPE, ti->tile);
	if (water_base == 0) {
		/* Use default sprites. */
		water_base = SPR_CANALS_BASE;
	} else if (HasBit(_water_feature[CF_WATERSLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
		/* NewGRF supplies a flat sprite as first sprite. */
		if (image == SPR_FLAT_WATER_TILE) {
			image = water_base;
		} else {
			image++;
		}
	}

	if (image < 5) image += water_base;
	DrawGroundSprite(image, PAL_NONE);

	/* Draw structures. */
	uint     zoffs = 0;
	SpriteID base  = GetCanalSprite(CF_LOCKS, ti->tile);

	if (base == 0) {
		/* If no custom graphics, use defaults. */
		base = SPR_LOCK_BASE;
		zoffs = ti->z > wdts[3].delta_y ? 24 : 0;
	}

	DrawWaterTileStruct(ti, wdts, base, zoffs, PAL_NONE, CF_LOCKS);
}

/** Draw a ship depot tile. */
static void DrawWaterDepot(const TileInfo *ti)
{
	DrawWaterClassGround(ti);
	/* Skip first entry in _shipdepot_display_seq as this is the ground sprite. */
	DrawWaterTileStruct(ti, _shipdepot_display_seq[GetSection(ti->tile)] + 1, 0, 0, COMPANY_SPRITE_COLOUR(GetTileOwner(ti->tile)), CF_END);
}

static void DrawRiverWater(const TileInfo *ti)
{
	SpriteID image = SPR_FLAT_WATER_TILE;
	uint     offset = 0;
	uint     edges_offset = 0;

	if (ti->tileh != SLOPE_FLAT || HasBit(_water_feature[CF_RIVER_SLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
		image = GetCanalSprite(CF_RIVER_SLOPE, ti->tile);
		if (image == 0) {
			switch (ti->tileh) {
				case SLOPE_NW: image = SPR_WATER_SLOPE_Y_DOWN; break;
				case SLOPE_SW: image = SPR_WATER_SLOPE_X_UP;   break;
				case SLOPE_SE: image = SPR_WATER_SLOPE_Y_UP;   break;
				case SLOPE_NE: image = SPR_WATER_SLOPE_X_DOWN; break;
				default:       image = SPR_FLAT_WATER_TILE;    break;
			}
		} else {
			/* Flag bit 0 indicates that the first sprite is flat water. */
			offset = HasBit(_water_feature[CF_RIVER_SLOPE].flags, CFF_HAS_FLAT_SPRITE) ? 1 : 0;

			switch (ti->tileh) {
				case SLOPE_SE:              edges_offset += 12; break;
				case SLOPE_NE: offset += 1; edges_offset += 24; break;
				case SLOPE_SW: offset += 2; edges_offset += 36; break;
				case SLOPE_NW: offset += 3; edges_offset += 48; break;
				default:       offset  = 0; break;
			}

			offset = GetCanalSpriteOffset(CF_RIVER_SLOPE, ti->tile, offset);
		}
	}

	DrawGroundSprite(image + offset, PAL_NONE);

	/* Draw river edges if available. */
	DrawWaterEdges(false, edges_offset, ti->tile);
}

void DrawShoreTile(Slope tileh)
{
	/* Converts the enum Slope into an offset based on SPR_SHORE_BASE.
	 * This allows to calculate the proper sprite to display for this Slope */
	static const byte tileh_to_shoresprite[32] = {
		0, 1, 2, 3, 4, 16, 6, 7, 8, 9, 17, 11, 12, 13, 14, 0,
		0, 0, 0, 0, 0,  0, 0, 0, 0, 0,  0,  5,  0, 10, 15, 0,
	};

	assert(!IsHalftileSlope(tileh)); // Halftile slopes need to get handled earlier.
	assert(tileh != SLOPE_FLAT);     // Shore is never flat

	assert((tileh != SLOPE_EW) && (tileh != SLOPE_NS)); // No suitable sprites for current flooding behaviour

	DrawGroundSprite(SPR_SHORE_BASE + tileh_to_shoresprite[tileh], PAL_NONE);
}

void DrawWaterClassGround(const TileInfo *ti)
{
	switch (GetWaterClass(ti->tile)) {
		case WATER_CLASS_SEA:   DrawSeaWater(ti->tile); break;
		case WATER_CLASS_CANAL: DrawCanalWater(ti->tile); break;
		case WATER_CLASS_RIVER: DrawRiverWater(ti); break;
		default: NOT_REACHED();
	}
}

static void DrawTile_Water(TileInfo *ti)
{
	switch (GetWaterTileType(ti->tile)) {
		case WATER_TILE_CLEAR:
			DrawWaterClassGround(ti);
			DrawBridgeMiddle(ti);
			break;

		case WATER_TILE_COAST: {
			DrawShoreTile(ti->tileh);
			DrawBridgeMiddle(ti);
			break;
		}

		case WATER_TILE_LOCK:
			DrawWaterLock(ti);
			break;

		case WATER_TILE_DEPOT:
			DrawWaterDepot(ti);
			break;
	}
}

void DrawShipDepotSprite(int x, int y, int image)
{
	const WaterDrawTileStruct *wdts = _shipdepot_display_seq[image];

	DrawSprite(wdts++->image, PAL_NONE, x, y);

	for (; wdts->delta_x != 0x80; wdts++) {
		Point pt = RemapCoords(wdts->delta_x, wdts->delta_y, wdts->delta_z);
		DrawSprite(wdts->image, COMPANY_SPRITE_COLOUR(_local_company), x + pt.x, y + pt.y);
	}
}


static uint GetSlopeZ_Water(TileIndex tile, uint x, uint y)
{
	uint z;
	Slope tileh = GetTileSlope(tile, &z);

	return z + GetPartialZ(x & 0xF, y & 0xF, tileh);
}

static Foundation GetFoundation_Water(TileIndex tile, Slope tileh)
{
	return FOUNDATION_NONE;
}

static void GetTileDesc_Water(TileIndex tile, TileDesc *td)
{
	switch (GetWaterTileType(tile)) {
		case WATER_TILE_CLEAR:
			switch (GetWaterClass(tile)) {
				case WATER_CLASS_SEA:   td->str = STR_LAI_WATER_DESCRIPTION_WATER; break;
				case WATER_CLASS_CANAL: td->str = STR_LAI_WATER_DESCRIPTION_CANAL; break;
				case WATER_CLASS_RIVER: td->str = STR_LAI_WATER_DESCRIPTION_RIVER; break;
				default: NOT_REACHED(); break;
			}
			break;
		case WATER_TILE_COAST: td->str = STR_LAI_WATER_DESCRIPTION_COAST_OR_RIVERBANK; break;
		case WATER_TILE_LOCK : td->str = STR_LAI_WATER_DESCRIPTION_LOCK;               break;
		case WATER_TILE_DEPOT:
			td->str = STR_LAI_WATER_DESCRIPTION_SHIP_DEPOT;
			td->build_date = Depot::GetByTile(tile)->build_date;
			break;
		default: NOT_REACHED(); break;
	}

	td->owner[0] = GetTileOwner(tile);
}

/**
 * Handle the flooding of a vehicle. This sets the vehicle state to crashed,
 * creates a newsitem and dirties the necessary windows.
 * @param v The vehicle to flood.
 */
static void FloodVehicle(Vehicle *v)
{
	uint pass = v->Crash(true);

	AI::NewEvent(v->owner, new AIEventVehicleCrashed(v->index, v->tile, AIEventVehicleCrashed::CRASH_FLOODED));
	SetDParam(0, pass);
	AddVehicleNewsItem(STR_NEWS_DISASTER_FLOOD_VEHICLE, NS_ACCIDENT, v->index);
	CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
	SndPlayVehicleFx(SND_12_EXPLOSION, v);
}

/**
 * Flood a vehicle if we are allowed to flood it, i.e. when it is on the ground.
 * @param v    The vehicle to test for flooding.
 * @param data The z of level to flood.
 * @return NULL as we always want to remove everything.
 */
static Vehicle *FloodVehicleProc(Vehicle *v, void *data)
{
	if ((v->vehstatus & VS_CRASHED) != 0) return NULL;

	switch (v->type) {
		default: break;

		case VEH_AIRCRAFT: {
			if (!IsAirportTile(v->tile) || GetTileMaxZ(v->tile) != 0) break;
			if (v->subtype == AIR_SHADOW) break;

			/* We compare v->z_pos against delta_z + 1 because the shadow
			 * is at delta_z and the actual aircraft at delta_z + 1. */
			const Station *st = Station::GetByTile(v->tile);
			const AirportFTAClass *airport = st->airport.GetFTA();
			if (v->z_pos != airport->delta_z + 1) break;

			FloodVehicle(v);
			break;
		}

		case VEH_TRAIN:
		case VEH_ROAD: {
			byte z = *(byte*)data;
			if (v->z_pos > z) break;
			FloodVehicle(v->First());
			break;
		}
	}

	return NULL;
}

/**
 * Finds a vehicle to flood.
 * It does not find vehicles that are already crashed on bridges, i.e. flooded.
 * @param tile the tile where to find a vehicle to flood
 */
static void FloodVehicles(TileIndex tile)
{
	byte z = 0;

	if (IsAirportTile(tile)) {
		const Station *st = Station::GetByTile(tile);
		TILE_AREA_LOOP(tile, st->airport) {
			if (st->TileBelongsToAirport(tile)) FindVehicleOnPos(tile, &z, &FloodVehicleProc);
		}

		/* No vehicle could be flooded on this airport anymore */
		return;
	}

	/* if non-uniform stations are disabled, flood some train in this train station (if there is any) */
	if (!_settings_game.station.nonuniform_stations && IsTileType(tile, MP_STATION) && GetStationType(tile) == STATION_RAIL) {
		const Station *st = Station::GetByTile(tile);

		TILE_AREA_LOOP(t, st->train_station) {
			if (st->TileBelongsToRailStation(t)) {
				FindVehicleOnPos(tile, &z, &FloodVehicleProc);
			}
		}

		return;
	}

	if (!IsBridgeTile(tile)) {
		FindVehicleOnPos(tile, &z, &FloodVehicleProc);
		return;
	}

	TileIndex end = GetOtherBridgeEnd(tile);
	z = GetBridgeHeight(tile);

	FindVehicleOnPos(tile, &z, &FloodVehicleProc);
	FindVehicleOnPos(end, &z, &FloodVehicleProc);
}

/**
 * Returns the behaviour of a tile during flooding.
 *
 * @return Behaviour of the tile
 */
FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
{
	/* FLOOD_ACTIVE:  'single-corner-raised'-coast, sea, sea-shipdepots, sea-buoys, sea-docks (water part), rail with flooded halftile, sea-water-industries, sea-oilrigs
	 * FLOOD_DRYUP:   coast with more than one corner raised, coast with rail-track, coast with trees
	 * FLOOD_PASSIVE: (not used)
	 * FLOOD_NONE:    canals, rivers, everything else
	 */
	switch (GetTileType(tile)) {
		case MP_WATER:
			if (IsCoast(tile)) {
				Slope tileh = GetTileSlope(tile, NULL);
				return (IsSlopeWithOneCornerRaised(tileh) ? FLOOD_ACTIVE : FLOOD_DRYUP);
			}
			/* FALL THROUGH */
		case MP_STATION:
		case MP_INDUSTRY:
		case MP_OBJECT:
			return (GetWaterClass(tile) == WATER_CLASS_SEA) ? FLOOD_ACTIVE : FLOOD_NONE;

		case MP_RAILWAY:
			if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
				return (IsSlopeWithOneCornerRaised(GetTileSlope(tile, NULL)) ? FLOOD_ACTIVE : FLOOD_DRYUP);
			}
			return FLOOD_NONE;

		case MP_TREES:
			return (GetTreeGround(tile) == TREE_GROUND_SHORE ? FLOOD_DRYUP : FLOOD_NONE);

		default:
			return FLOOD_NONE;
	}
}

/**
 * Floods a tile.
 */
void DoFloodTile(TileIndex target)
{
	assert(!IsTileType(target, MP_WATER));

	bool flooded = false; // Will be set to true if something is changed.

	Backup<CompanyByte> cur_company(_current_company, OWNER_WATER, FILE_LINE);

	Slope tileh = GetTileSlope(target, NULL);
	if (tileh != SLOPE_FLAT) {
		/* make coast.. */
		switch (GetTileType(target)) {
			case MP_RAILWAY: {
				if (!IsPlainRail(target)) break;
				FloodVehicles(target);
				flooded = FloodHalftile(target);
				break;
			}

			case MP_TREES:
				if (!IsSlopeWithOneCornerRaised(tileh)) {
					SetTreeGroundDensity(target, TREE_GROUND_SHORE, 3);
					MarkTileDirtyByTile(target);
					flooded = true;
					break;
				}
				/* FALL THROUGH */

			case MP_CLEAR:
				if (DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
					MakeShore(target);
					MarkTileDirtyByTile(target);
					flooded = true;
				}
				break;

			default:
				break;
		}
	} else {
		/* Flood vehicles */
		FloodVehicles(target);

		/* flood flat tile */
		if (DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
			MakeSea(target);
			MarkTileDirtyByTile(target);
			flooded = true;
		}
	}

	if (flooded) {
		/* Mark surrounding canal tiles dirty too to avoid glitches */
		MarkCanalsAndRiversAroundDirty(target);

		/* update signals if needed */
		UpdateSignalsInBuffer();
	}

	cur_company.Restore();
}

/**
 * Drys a tile up.
 */
static void DoDryUp(TileIndex tile)
{
	Backup<CompanyByte> cur_company(_current_company, OWNER_WATER, FILE_LINE);

	switch (GetTileType(tile)) {
		case MP_RAILWAY:
			assert(IsPlainRail(tile));
			assert(GetRailGroundType(tile) == RAIL_GROUND_WATER);

			RailGroundType new_ground;
			switch (GetTrackBits(tile)) {
				case TRACK_BIT_UPPER: new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
				case TRACK_BIT_LOWER: new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
				case TRACK_BIT_LEFT:  new_ground = RAIL_GROUND_FENCE_VERT1;  break;
				case TRACK_BIT_RIGHT: new_ground = RAIL_GROUND_FENCE_VERT2;  break;
				default: NOT_REACHED();
			}
			SetRailGroundType(tile, new_ground);
			MarkTileDirtyByTile(tile);
			break;

		case MP_TREES:
			SetTreeGroundDensity(tile, TREE_GROUND_GRASS, 3);
			MarkTileDirtyByTile(tile);
			break;

		case MP_WATER:
			assert(IsCoast(tile));

			if (DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
				MakeClear(tile, CLEAR_GRASS, 3);
				MarkTileDirtyByTile(tile);
			}
			break;

		default: NOT_REACHED();
	}

	cur_company.Restore();
}

/**
 * Let a water tile floods its diagonal adjoining tiles
 * called from tunnelbridge_cmd, and by TileLoop_Industry() and TileLoop_Track()
 *
 * @param tile the water/shore tile that floods
 */
void TileLoop_Water(TileIndex tile)
{
	switch (GetFloodingBehaviour(tile)) {
		case FLOOD_ACTIVE:
			for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
				TileIndex dest = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDir(dir));
				if (dest == INVALID_TILE) continue;
				/* do not try to flood water tiles - increases performance a lot */
				if (IsTileType(dest, MP_WATER)) continue;

				uint z_dest;
				Slope slope_dest = GetFoundationSlope(dest, &z_dest) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
				if (z_dest > 0) continue;

				if (!HasBit(_flood_from_dirs[slope_dest], ReverseDir(dir))) continue;

				DoFloodTile(dest);
			}
			break;

		case FLOOD_DRYUP: {
			Slope slope_here = GetFoundationSlope(tile, NULL) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
			uint dir;
			FOR_EACH_SET_BIT(dir, _flood_from_dirs[slope_here]) {
				TileIndex dest = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDir((Direction)dir));
				if (dest == INVALID_TILE) continue;

				FloodingBehaviour dest_behaviour = GetFloodingBehaviour(dest);
				if ((dest_behaviour == FLOOD_ACTIVE) || (dest_behaviour == FLOOD_PASSIVE)) return;
			}
			DoDryUp(tile);
			break;
		}

		default: return;
	}
}

void ConvertGroundTilesIntoWaterTiles()
{
	uint z;

	for (TileIndex tile = 0; tile < MapSize(); ++tile) {
		Slope slope = GetTileSlope(tile, &z);
		if (IsTileType(tile, MP_CLEAR) && z == 0) {
			/* Make both water for tiles at level 0
			 * and make shore, as that looks much better
			 * during the generation. */
			switch (slope) {
				case SLOPE_FLAT:
					MakeSea(tile);
					break;

				case SLOPE_N:
				case SLOPE_E:
				case SLOPE_S:
				case SLOPE_W:
					MakeShore(tile);
					break;

				default:
					uint dir;
					FOR_EACH_SET_BIT(dir, _flood_from_dirs[slope & ~SLOPE_STEEP]) {
						TileIndex dest = TILE_ADD(tile, TileOffsByDir((Direction)dir));
						Slope slope_dest = GetTileSlope(dest, NULL) & ~SLOPE_STEEP;
						if (slope_dest == SLOPE_FLAT || IsSlopeWithOneCornerRaised(slope_dest)) {
							MakeShore(tile);
							break;
						}
					}
					break;
			}
		}
	}
}

static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
{
	static const byte coast_tracks[] = {0, 32, 4, 0, 16, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0};

	TrackBits ts;

	if (mode != TRANSPORT_WATER) return 0;

	switch (GetWaterTileType(tile)) {
		case WATER_TILE_CLEAR: ts = (GetTileSlope(tile, NULL) == SLOPE_FLAT) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break;
		case WATER_TILE_COAST: ts = (TrackBits)coast_tracks[GetTileSlope(tile, NULL) & 0xF]; break;
		case WATER_TILE_LOCK:  ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break;
		case WATER_TILE_DEPOT: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break;
		default: return 0;
	}
	if (TileX(tile) == 0) {
		/* NE border: remove tracks that connects NE tile edge */
		ts &= ~(TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT);
	}
	if (TileY(tile) == 0) {
		/* NW border: remove tracks that connects NW tile edge */
		ts &= ~(TRACK_BIT_Y | TRACK_BIT_LEFT | TRACK_BIT_UPPER);
	}
	return CombineTrackStatus(TrackBitsToTrackdirBits(ts), TRACKDIR_BIT_NONE);
}

static bool ClickTile_Water(TileIndex tile)
{
	if (GetWaterTileType(tile) == WATER_TILE_DEPOT) {
		ShowDepotWindow(GetShipDepotNorthTile(tile), VEH_SHIP);
		return true;
	}
	return false;
}

static void ChangeTileOwner_Water(TileIndex tile, Owner old_owner, Owner new_owner)
{
	if (!IsTileOwner(tile, old_owner)) return;

	if (new_owner != INVALID_OWNER) {
		SetTileOwner(tile, new_owner);
		return;
	}

	/* Remove depot */
	if (IsShipDepot(tile)) DoCommand(tile, 0, 0, DC_EXEC | DC_BANKRUPT, CMD_LANDSCAPE_CLEAR);

	/* Set owner of canals and locks ... and also canal under dock there was before.
	 * Check if the new owner after removing depot isn't OWNER_WATER. */
	if (IsTileOwner(tile, old_owner)) SetTileOwner(tile, OWNER_NONE);
}

static VehicleEnterTileStatus VehicleEnter_Water(Vehicle *v, TileIndex tile, int x, int y)
{
	return VETSB_CONTINUE;
}

static CommandCost TerraformTile_Water(TileIndex tile, DoCommandFlag flags, uint z_new, Slope tileh_new)
{
	/* Canals can't be terraformed */
	if (IsWaterTile(tile) && IsCanal(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_CANAL_FIRST);

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


extern const TileTypeProcs _tile_type_water_procs = {
	DrawTile_Water,           // draw_tile_proc
	GetSlopeZ_Water,          // get_slope_z_proc
	ClearTile_Water,          // clear_tile_proc
	NULL,                     // add_accepted_cargo_proc
	GetTileDesc_Water,        // get_tile_desc_proc
	GetTileTrackStatus_Water, // get_tile_track_status_proc
	ClickTile_Water,          // click_tile_proc
	NULL,                     // animate_tile_proc
	TileLoop_Water,           // tile_loop_clear
	ChangeTileOwner_Water,    // change_tile_owner_clear
	NULL,                     // add_produced_cargo_proc
	VehicleEnter_Water,       // vehicle_enter_tile_proc
	GetFoundation_Water,      // get_foundation_proc
	TerraformTile_Water,      // terraform_tile_proc
};