Prevent injection of floating-point delays, that wreck advtrains - advtrains.git

diff options

author	Gabriel Pérez-Cerezo <gabriel@gpcf.eu>	2019-07-20 19:26:55 +0200
committer	Gabriel Pérez-Cerezo <gabriel@gpcf.eu>	2019-07-20 19:26:55 +0200
commit	896baf8e05c4a17f6c302edbfff27f1e96fa08f0 (patch)
tree	90312ebe6edba10f2c2f0aebb08ba052f024756c /models
parent	d6de12ded6ec4676c52882411cbb67c6d6979849 (diff)
download	advtrains-896baf8e05c4a17f6c302edbfff27f1e96fa08f0.tar.gz advtrains-896baf8e05c4a17f6c302edbfff27f1e96fa08f0.tar.bz2 advtrains-896baf8e05c4a17f6c302edbfff27f1e96fa08f0.zip

Prevent injection of floating-point delays, that wreck advtrains

Diffstat (limited to 'models')

0 files changed, 0 insertions, 0 deletions

'#n106'>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

local al = advtrains.lines
local rwt = assert(advtrains.lines.rwt)

local MODE_NORMAL = 0 -- normální zastávka (výchozí nebo mezilehlá)
local MODE_REQUEST_STOP = 1 -- zastávka na znamení (mezilehlá)
local MODE_HIDDEN = 2 -- skrytá zastávka (výchozí nebo mezilehlá)
local MODE_DISABLED = 3 -- vypnutá zastávka (mezilehlá nebo koncová)
local MODE_FINAL = 4 -- koncová zastávka (linka zde jízdu končí)
local MODE_FINAL_HIDDEN = 5 -- koncová zastávka skrytá
local MODE_FINAL_CONTINUE = 6 -- koncová zastávka (vlak pokračuje jako jiná linka)

local simple_modes = {
    [MODE_NORMAL] = MODE_NORMAL,
    [MODE_REQUEST_STOP] = MODE_NORMAL,
    [MODE_HIDDEN] = MODE_NORMAL,
    [MODE_DISABLED] = MODE_DISABLED,
    [MODE_FINAL] = MODE_FINAL,
    [MODE_FINAL_HIDDEN] = MODE_FINAL,
    [MODE_FINAL_CONTINUE] = MODE_FINAL,
}

local current_passages = {--[[
    [train_id] = {
        [1] = rwtime,
        ...,
        [n] = rwtime (časy *odjezdu*, kromě koncových zastávek, kde jde o čas příjezdu)
        wait = int or nil (původně naplánovaná doba čekání na výchozí zastávce)
    }
]]}

local last_passages = {--[[
    [linevar] = {
        [1..10] = {[1] = rwtime, ..., wait} -- jízdy seřazeny od nejstarší (1) po nejnovější (až 10) podle odjezdu z výchozí zastávky
    }
]]}

local diakritika_na_velka = {
	["á"] = "Á", ["ä"] = "Ä", ["č"] = "Č", ["ď"] = "Ď", ["é"] = "É", ["Ě"] = "Ě", ["Í"] = "Í", ["ĺ"] = "Ĺ", ["ľ"] = "Ľ",
	["ň"] = "Ň", ["ó"] = "Ó", ["ô"] = "Ô", ["ŕ"] = "Ŕ", ["ř"] = "Ř", ["š"] = "Š", ["ť"] = "Ť", ["ú"] = "Ú", ["ů"] = "Ů",
	["ý"] = "Ý", ["ž"] = "Ž",
}

local debug_print_i = 0

-- LOCAL funkce:
-- =========================================================================
local function debug_print(s)
    debug_print_i = debug_print_i + 1
    -- core.chat_send_all("["..debug_print_i.."] "..tostring(s))
    return s
end

-- Je-li stn kód stanice, vrací její jméno, jinak vrací "???". stn může být i nil.
local function get_station_name(stn)
    local station = advtrains.lines.stations[stn or ""]
    if station ~= nil and station.name ~= nil then
        return station.name
    else
        return "???"
    end
end
al.get_station_name = get_station_name

local function na_velka_pismena(s)
	local l = #s
	local i = 1
	local res = ""
	local c
	while i <= l do
		c = diakritika_na_velka[s:sub(i, i + 1)]
		if c then
			res = res .. c
			i = i + 2
		else
			res = res .. s:sub(i, i)
			i = i + 1
		end
	end
	return string.upper(res)
end

--[[
    -- Vrací index následujícího výskytu 'stn' v seznamu zastávek podle linevar_def.
    -- Vrací i skryté zastávky, ale ne vypnuté.
    -- Je-li linevar_def == nil nebo stn == nil nebo stn == "", vrací nil.
    - line_status = table
    - linevar_def = table or nil
    - stn = string
    return: int or nil
]]
local function find_next_index(line_status, linevar_def, stn)
    assert(line_status)
    if linevar_def ~= nil and stn ~= nil and stn ~= "" then
        local stops = linevar_def.stops
        if line_status.linevar_index < #stops then
            for i = line_status.linevar_index + 1, #stops do
                local stop = stops[i]
                if stop.stn == stn and (stop.mode or MODE_NORMAL) ~= MODE_DISABLED then
                    return i
                end
            end
        end
    end
end

-- Vrací kódy výchozí a cílové stanice k zobrazení cestujícím: stn_first (string), stn_terminus (string)
-- Předané linevar_def musí obsahovat platný seznam 'stops', ale nemusí obsahovat nic jiného (nemusí to být platná definice).
-- V případě chyby vrací nil, nil.
local function get_first_last_stations(linevar_def)
    local a, b = linevar_def.index_vychozi, linevar_def.index_cil
    if a ~= nil and b ~= nil then
        local stops = linevar_def.stops
        return stops[a].stn, stops[b].stn
    else
        return nil, nil
    end
end

--[[
    Používá se na *nelinkový* vlak stojící na *neanonymní* zastávce.
    Zahájí jízdu na lince nalezené podle kombinace line/stn/rc, nebo vrátí false.
]]
local function line_start(train, stn, departure_rwtime)
    assert(train)
    assert(stn and stn ~= "")
    assert(departure_rwtime)
    local ls = al.get_line_status(train)
    if ls.linevar ~= nil then
        error("line_start() used on a train that is already on a line: "..dump2({train = train}))
    end
    local linevar, linevar_def = al.try_get_linevar(train.line, stn, train.routingcode)
    if linevar == nil or linevar_def.disabled then
        return false
    end
    ls.linevar = linevar
    ls.linevar_station = stn
    ls.linevar_index = 1
    ls.linevar_dep = departure_rwtime
    ls.linevar_last_dep = departure_rwtime
    ls.linevar_last_stn = stn
    ls.linevar_past = nil
    train.text_outside = al.get_line_description(linevar_def, {
        line_number = true,
        last_stop = true,
        last_stop_prefix = "",
        last_stop_uppercase = true,
        train_name = true,
    })
    return true
end

--[[
    Vrací:
    - "true", pokud má vlak zastavit
    - nil, pokud zastavit nemá
    - "on_request", pokud má zastavit na znamení, ale znamení zatím nebylo dáno
]]
local function should_stop(pos, stdata, train)
    if stdata == nil or stdata.stn == nil then
        return nil -- neplatná data
    end
	local n_trainparts = #assert(train.trainparts)
    -- vyhovuje počet vagonů?
    if not ((stdata.minparts or 0) <= n_trainparts and n_trainparts <= (stdata.maxparts or 128)) then
        return nil
    end
    local stn = assert(stdata.stn) -- zastávka stále může být anonymní
	local ls, linevar_def = al.get_line_status(train)
    local next_index
    if stn ~= "" then
        next_index = find_next_index(ls, linevar_def, stn)
    end
    -- jde o linkový vlak?
    if linevar_def ~= nil then
        if next_index == nil then
            return nil
        end
        local stop = assert(linevar_def.stops[next_index])
        if stop.pos ~= nil and stop.pos ~= string.format("%d,%d,%d", pos.x, pos.y, pos.z) then
            return nil
        end
        if stop.mode ~= nil and stop.mode == MODE_REQUEST_STOP then
            if ls.stop_request ~= nil then
                debug_print("Vlak "..train.id.." zastaví na zastávce na znamení.")
                return "true"
            else
                debug_print("Vlak "..train.id.." možná zastaví na zastávce na znamení.")
                return "on_request"
            end
        end
        return "true"
        -- TODO: zastávky na znamení
    else
        local ars = stdata.ars
        -- vyhovuje vlak ARS pravidlům?
        local result = ars and (ars.default or advtrains.interlocking.ars_check_rule_match(ars, train))
        if result then
            return "true"
        else
            return nil
        end
    end
end

local function update_value(train, key, setting)
    if setting == "-" then
        train[key] = nil
    elseif setting ~= "" then
        train[key] = setting
    end
    return train[key]
end

--[[
    Pokud vlak jede na lince, odebere ho z této linky a vrátí true; jinak vrátí false.
]]
function al.cancel_linevar(train)
    local ls = train.line_status
    if ls == nil or ls.linevar == nil then return false end
    ls.linevar = nil
    ls.linevar_station = nil
    ls.linevar_index = nil
    ls.linevar_dep = nil
    ls.linevar_last_dep = nil
    ls.linevar_last_stn = nil
    train.text_outside = ""
    return true
end

-- Vrací seznam názvů neskrytých zastávek, počínaje od uvedeného indexu.
-- Pokud by vrátila prázdný seznam, vrátí místo něj {"???"}.
function al.get_stop_names(linevar_def, start_index)
    local stations = advtrains.lines.stations
    local result = {}
    if linevar_def ~= nil then
        local stops = linevar_def.stops
        if start_index == nil then
            start_index = 1
        end
        for i = start_index, #stops do
            local stop = stops[i]
            if stop.mode == nil or (stop.mode ~= MODE_HIDDEN and stop.mode ~= MODE_FINAL_HIDDEN and stop.mode ~= MODE_DISABLED) then
                local station = stations[stop.stn]
                if station ~= nil and station.name ~= nil and station.name ~= "" then
                    table.insert(result, station.name)
                else
                    table.insert(result, "???")
                end
            end
        end
    end
    if result[1] == nil then
        result[1] = "???"
    end
    return result
end

--[[
    Vrací:
    a) index, stop_data -- pokud byla vyhovující předchozí zastávka nalezena
    b) nil, nil -- pokud nalezena nebyla
]]
function al.get_first_stop(linevar_def, allow_hidden_stops)
    if allow_hidden_stops then
        return 1, linevar_def.stops[1]
    else
        local result = linevar_def.index_vychozi
        if result ~= nil then
            return result, linevar_def.stops[result]
        else
            return nil, nil
        end
    end
end

--[[
    Vrací:
    a) index, stop_data -- pokud byla vyhovující předchozí zastávka nalezena
    b) nil, nil -- pokud nalezena nebyla
]]
function al.get_last_stop(linevar_def, allow_hidden_stops)
    if allow_hidden_stops then
        local stops = linevar_def.stops[result]
        for i = linevar_def.index_cil, #stops do
            local stop = stops[i]
            local mode = stop.mode
            if mode == MODE_FINAL or mode == MODE_FINAL_CONTINUE or mode == MODE_FINAL_HIDDEN then
                return i, stop
            end
        end
    else
        local result = linevar_def.index_cil
        if result ~= nil then
            return result, linevar_def.stops[result]
        end
    end
    return nil, nil
end

--[[
    Vrací:
    a) index, stop_data -- pokud byla vyhovující předchozí zastávka nalezena
    b) nil, nil -- pokud nalezena nebyla
]]
function al.get_prev_stop(linevar_def, current_index, allow_hidden_stops)
    local stops = assert(linevar_def.stops)
    assert(current_index)
    if current_index > 1 then
        for i = current_index - 1, 1, -1 do
            local mode = stops[i].mode
            if mode == nil or (mode ~= MODE_DISABLED and ((mode ~= MODE_HIDDEN and mode ~= MODE_FINAL_HIDDEN) or allow_hidden_stops)) then
                return i, stops[i]
            end
        end
    end
    return nil, nil
end

--[[
    Vrací:
    a) index, stop_data -- pokud byla vyhovující další zastávka nalezena
    b) nil, nil -- pokud nalezena nebyla
]]
function al.get_next_stop(linevar_def, current_index, allow_hidden_stops)
    local stops = assert(linevar_def.stops)
    assert(current_index)
    if current_index < #stops then
        for i = current_index + 1, #stops do
            local mode = stops[i].mode
            if mode == nil or (mode ~= MODE_DISABLED and ((mode ~= MODE_HIDDEN and mode ~= MODE_FINAL_HIDDEN) or allow_hidden_stops)) then
                return i, stops[i]
            end
        end
    end
    return nil, nil
end

--[[
    Vrací:
    a) index, stop_data -- pokud byla vyhovující koncová zastávka nalezena
    b) nil, nil -- pokud nalezena nebyla
]]
function al.get_terminus(linevar_def, current_index, allow_hidden_stops)
    if linevar_def.index_cil ~= nil then
        return linevar_def.index_cil, linevar_def.stops[linevar_def.index_cil]
    end
    local stops = assert(linevar_def.stops)
    local r_i, r_stop
    if current_index < #stops then
        for i = current_index + 1, #stops do
            local mode = stops[i].mode or MODE_NORMAL
            if mode ~= MODE_DISABLED and ((mode ~= MODE_HIDDEN and mode ~= MODE_FINAL_HIDDEN) or allow_hidden_stops) then
                r_i, r_stop = i, stops[i]
            end
            if mode == MODE_FINAL or mode == MODE_FINAL_CONTINUE or mode == MODE_FINAL_HIDDEN then
                break
            end
        end
    end
    return r_i, r_stop
end

--[[
    options = {
        line_number = bool or nil, -- zahrnout do popisu číslo linky? nil => false
        first_stop = bool or nil, -- zahrnout do popisu název výchozí zastávky? nil => false
        last_stop = bool or nil, -- zahrnout do popisu název cílové zastávky? nil => true
        last_stop_prefix = string or nil, -- text před název cílové zastávky; nil => "⇒ "
        last_stop_uppercase = bool or nil, -- je-li true, název cílové zastávky se před uvedením převede na velká písmena
        train_name = bool or nil, -- zahrnout do popisu jméno vlaku, je-li k dispozici; nil => false
        train_name_prefix = string or nil, -- text před jméno vlaku; nil => "\n"
    }
]]
function al.get_line_description(linevar_def, options)
    local line, stn = al.linevar_decompose(linevar_def.name)
    local first_stn, last_stn = get_first_last_stations(linevar_def)
    if line == nil or first_stn == nil or last_stn == nil then
        return "???"
    end
    if options == nil then options = {} end
    local s1, s2, s3, s4
    if options.line_number then
        s1 = "["..line.."] "
    else
        s1 = ""
    end
    if first_stn == last_stn and options.first_stop and (options.last_stop == nil or options.last_stop) then
        s2 = get_station_name(last_stn)
        if options.last_stop_uppercase then
            s2 = na_velka_pismena(s2)
        end
        s3 = " (okružní)"
    else
        if options.first_stop then
            s2 = get_station_name(first_stn).." "
        else
            s2 = ""
        end
        if options.last_stop == nil or options.last_stop then
            s3 = get_station_name(last_stn)
            if options.last_stop_uppercase then
                s3 = na_velka_pismena(s3)
            end
            s3 = (options.last_stop_prefix or "⇒ ")..s3
        else
            s3 = ""
        end
    end
    if options.train_name and linevar_def.train_name ~= nil then
        s4 = (options.train_name_prefix or "\n")..linevar_def.train_name
    else
        s4 = ""
    end
    return s1..s2..s3..s4
end

function al.get_stop_description(stop_data, next_stop_data)
    local s1, s2 = "", ""
    if stop_data ~= nil then
        local mode = stop_data.mode
        if mode ~= MODE_DISABLED and mode ~= MODE_HIDDEN and mode ~= MODE_FINAL_HIDDEN then
            s1 = get_station_name(stop_data.stn)
            --[[
            if
                mode == MODE_FINAL or mode == MODE_FINAL_CONTINUE or
                (next_stop_data ~= nil and next_stop_data.mode == MODE_FINAL_HIDDEN)
            then
                s2 = "Koncová zastávka"
            end
            ]]
        end
    end
    if next_stop_data ~= nil then
        local mode = next_stop_data.mode
        if mode ~= MODE_DISABLED and mode ~= MODE_HIDDEN and mode ~= MODE_FINAL_HIDDEN then
            s2 = "Příští zastávka/stanice: "..get_station_name(next_stop_data.stn)
            if mode == MODE_REQUEST_STOP then
                s2 = s2.." (na znamení)"
            end
        end
    else
        s2 = "Koncová zastávka"
    end
    if s1 ~= "" and s2 ~= "" then
        return s1.."\n"..s2
    else
        return s1..s2
    end
end

--[[
    Není-li zpoždění k dispozici, vrací {text = ""}, jinak vrací:
    {
        has_delay = bool,
        delay = int,
        text = string,
    }
]]
function al.get_delay_description(line_status, linevar_def, rwtime)
    assert(line_status)
    if linevar_def == nil then
        return {text = ""}
    end
    local stops = linevar_def.stops
    local expected_departure = line_status.linevar_dep + assert(stops[line_status.linevar_index]).dep
    local real_departure = line_status.linevar_last_dep
    local delay = real_departure - expected_departure

    if rwtime ~= nil then
        local expected_departure_next
        for i = line_status.linevar_index + 1, #stops do
            if stops[i] == nil then
                break
            else
                local mode = stops[i].mode
                if mode == nil or mode ~= MODE_DISABLED then
                    expected_departure_next = line_status.linevar_dep + stops[i].dep
                    break
                end
            end
        end
        if expected_departure_next ~= nil then
            local delay2 = rwtime - expected_departure_next
            if delay2 > delay then
                delay = delay2
            end
        end
    end

    if delay < -1 or delay > 10 then
        return {
            has_delay = true,
            delay = delay,
            text = "zpoždění "..delay.." sekund",
        }
    else
        return {
            has_delay = false,
            delay = delay,
            text = "bez zpoždění",
        }
    end
end

-- Pokud zadaná varianta linky existuje, vrátí:
--      linevar_def, linevar_station
-- Jinak vrací:
--      nil, nil
-- Je-li linevar_station == nil, doplní se z linevar. Je-li linevar == nil, vrátí nil, nil.
function al.try_get_linevar_def(linevar, linevar_station)
    if linevar == nil then
        return nil, nil
    end
    if linevar_station == nil then
        local line
        line, linevar_station = al.linevar_decompose(linevar)
        if line == nil then
            return nil, nil
        end
    end
    local t = advtrains.lines.stations[linevar_station]
    if t ~= nil then
        t = t.linevars
        if t ~= nil then
            return t[linevar], linevar_station
        end
    end
    return nil, nil
end

--[[
    Vrací:
    a) nil, nil, pokud daná kombinace line/stn/rc nemá definovanou variantu linky
    b) linevar, linevar_def, pokud má
]]
function al.try_get_linevar(line, stn, rc)
    if line ~= nil and line ~= "" and stn ~= nil and stn ~= "" then
        local linevar = line.."/"..stn.."/"..(rc or "")
        local result = al.try_get_linevar_def(linevar, stn)
        if result ~= nil then
            return linevar, result
        end
    end
    return nil, nil
end

--[[
    Vrací 2 hodnoty:
    - line_status = table -- tabulka train.line_status (může být prázdná)
    - linevar_def = table or nil -- jde-li o linkový vlak, vrací definici linevar, jinak nil
    Parametry:
    - train = table (train)
]]
function al.get_line_status(train)
    assert(train)
    if train.line_status == nil then
        train.line_status = {}
        return train.line_status, nil
    end
    local ls = train.line_status
    if ls.linevar == nil then
        -- nelinkový vlak
        local linevar_past = ls.linevar_past
        if linevar_past ~= nil then
            local rwtime = rwt.to_secs(rwt.get_time())
            if train.line ~= linevar_past.line or rwtime - linevar_past.arrival >= 86400 then
                -- smazat linevar_past, pokud se změnilo označení linky nebo uplynulo 24 hodin
                ls.linevar_past = nil
            end
        end
        return ls, nil
    end
    local rwtime = rwt.to_secs(rwt.get_time())
    if rwtime - ls.linevar_dep >= 86400 then
        core.log("warning", "Train "..train.id.." put out of linevar '"..ls.linevar.."', because it was riding more then 24 hours.")
        al.cancel_linevar(train)
        return ls, nil
    end
    local linevar_def = al.try_get_linevar_def(ls.linevar, ls.linevar_station)
    if linevar_def == nil then
        core.log("warning", "Train "..train.id.." was riding a non-existent (undefined) line '"..tostring(ls.linevar).."'!")
        al.cancel_linevar(train)
    elseif linevar_def.stops[ls.linevar_index] == nil then
        core.log("warning", "Train "..train.id.." put out of linevar '"..ls.linevar.."', because its index "..ls.linevar_index.." became invalid.")
        al.cancel_linevar(train)
        linevar_def = nil
    else
        local train_line_prefix = (train.line or "").."/"
        if train_line_prefix ~= ls.linevar:sub(1, train_line_prefix:len()) then
            core.log("warning", "Train "..train.id.." put out of linevar '"..ls.linevar.."', because its line changed to '"..tostring(train.line).."'.")
            al.cancel_linevar(train)
            linevar_def = nil
        end
    end
    return ls, linevar_def
end

function al.on_train_approach(pos, train_id, train, index, has_entered)
    if has_entered then return end -- do not stop again!
    if train.path_cn[index] ~= 1 then return end -- špatný směr
    local pe = advtrains.encode_pos(pos)
    local stdata = advtrains.lines.stops[pe]
    if should_stop(pos, stdata, train) ~= nil then
        advtrains.lzb_add_checkpoint(train, index, 2, nil)
        if train.line_status.linevar == nil then
            -- nelinkový vlak:
            local stn = advtrains.lines.stations[stdata.stn]
            local stnname = stn and stn.name or attrans("Unknown Station")
            train.text_inside = attrans("Next Stop:") .. "\n"..stnname
        end
        advtrains.interlocking.ars_set_disable(train, true)
    end
end

local function record_skipped_stops(train_id, linevar_def, linevar_index, next_index)
    assert(linevar_def)
    if next_index > linevar_index + 1 then
        local skipped_stops = {}
        for i = linevar_index + 1, next_index - 1 do
            local mode = linevar_def.stops[i].mode or MODE_NORMAL
            if mode ~= MODE_DISABLED then
                table.insert(skipped_stops, linevar_def.stops[i].stn)
            end
        end
        if #skipped_stops > 0 then
            core.log("warning", "Train "..train_id.." of line '"..linevar_def.name.."' skipped "..#skipped_stops.." stops: "..
                table.concat(skipped_stops, ", "))
        end
        return #skipped_stops
    else
        return 0
    end
end

function al.on_train_enter(pos, train_id, train, index)
    if train.path_cn[index] ~= 1 then return end -- špatný směr
    local pe = advtrains.encode_pos(pos)
    local stdata = advtrains.lines.stops[pe]
    local stn = stdata.stn or ""
    local rwtime = assert(rwt.to_secs(rwt.get_time()))
    local ls, linevar_def = al.get_line_status(train)
    local next_index
    if stn ~= "" then
        if linevar_def ~= nil then
            next_index = find_next_index(ls, linevar_def, stn)
        end
        ls.last_enter = {stn = stn, encpos = pe, rwtime = rwtime}
        debug_print("Vlak "..train_id.." zaznamenán: "..stn.." "..core.pos_to_string(pos).." @ "..rwtime)
    end
    local should_stop_result = should_stop(pos, stdata, train)
    if should_stop_result == nil then
        debug_print("Vlak "..train_id.." projel zastávkou "..stn)
        return
    elseif should_stop_result == "on_request" then
        -- projetí zastávky na znamení
        debug_print("Vlak "..train_id.." projel zastávkou na znamení "..stn)
        if linevar_def ~= nil and next_index ~= nil then
            local stop_def = assert(linevar_def.stops[next_index])
            if stop_def.mode == nil or stop_def.mode ~= MODE_REQUEST_STOP then
                error("Internal error: mode "..MODE_REQUEST_STOP.." expected, but the real mode is "..tostring(stop_def.mode).."!")
            end
            assert(stn ~= "")
            record_skipped_stops(train_id, linevar_def, ls.linevar_index, next_index)
            ls.linevar_index = next_index
            ls.linevar_last_dep = rwtime -- u zastávky na znamení se průjezd počítá jako odjezd
            ls.linevar_last_stn = stn
            local next_stop_index, next_stop_data = al.get_next_stop(linevar_def, next_index)
            train.text_inside = al.get_stop_description(nil, linevar_def.stops[next_stop_index or 0])
            -- ATC command:
            local atc_command = "A1 S" ..(stdata.speed or "M")
            advtrains.atc.train_set_command(train, atc_command, true)
        end
        return
    end

    -- naplánovat čas odjezdu
    local wait = tonumber(stdata.wait) or 0
    local interval = stdata.interval
    local last_dep = stdata.last_dep -- posl. odjezd z této zastávkové koleje

    if interval ~= nil and last_dep ~= nil then
        if last_dep > rwtime then
            last_dep = rwtime
        end
        local ioffset = stdata.ioffset or 0
        local normal_dep = rwtime + wait
        local next_dep = last_dep + (interval - (last_dep + (interval - ioffset)) % interval)
        if normal_dep < next_dep then
            -- core.log("action", "[INFO] The train "..train_id.." will wait for "..(next_dep - normal_dep).." additional seconds due to interval at "..core.pos_to_string(pos)..".")
            wait = wait + (next_dep - normal_dep)
        -- else -- will wait normal time
        end
    end
    local planned_departure = rwtime + wait
    debug_print("Vlak "..train_id.." zastavil na "..stn.." a odjede za "..wait.." sekund ("..planned_departure..").")
    stdata.last_dep = planned_departure -- naplánovaný čas odjezdu
    stdata.last_wait = wait -- naplánovaná doba čekání
    ls.standing_at = pe
    if linevar_def == nil or next_index == nil or (linevar_def.stops[next_index].mode or MODE_NORMAL) ~= MODE_HIDDEN then
        -- zrušit stop_request, pokud jsme nezastavili na skryté zastávce:
        ls.stop_request = nil
    end

    local can_start_line
    local had_linevar = linevar_def ~= nil
    if linevar_def == nil then
        -- nelinkový vlak
        can_start_line = true
    elseif next_index ~= nil then
        -- linkový vlak zastavil na své řádné zastávce
        assert(stn ~= "") -- dopravna musí mít kód
        local stop_def = assert(linevar_def.stops[next_index])
        debug_print("Vlak "..train_id.." je linkový vlak ("..ls.linevar..") a zastavil na své pravidelné zastávce "..stn.." (index = "..next_index..")")
        record_skipped_stops(train_id, linevar_def, ls.linevar_index, next_index)
        local stop_smode = simple_modes[stop_def.mode or 0]
        if stop_smode == MODE_NORMAL then
            -- mezilehlá zastávka
            can_start_line = false
            ls.linevar_index = next_index
            ls.linevar_last_dep = planned_departure
            ls.linevar_last_stn = stn
            debug_print("Jde o mezilehlou zastávku.")
            local next_stop_index, next_stop_data = al.get_next_stop(linevar_def, next_index)
            train.text_inside = al.get_stop_description(linevar_def.stops[next_index], linevar_def.stops[next_stop_index or 0])
        else
            -- koncová zastávka
            can_start_line = stop_def.mode == MODE_FINAL_CONTINUE
            core.log("action", "Train "..train_id.." arrived at the final station "..stop_def.stn.." of linevar "..ls.linevar.." after "..(rwtime - ls.linevar_dep).." seconds.")
            debug_print("Vlak "..train_id.." skončil jízdu na lince "..ls.linevar..", může pokračovat na jinou linku: "..(can_start_line and "ihned" or "na příští zastávce"))
            train.text_inside = al.get_stop_description(linevar_def.stops[next_index])
            local current_passage = current_passages[train_id]
            if current_passage ~= nil then
                current_passage[next_index] = rwtime
                current_passages[train_id] = nil
            end
            al.cancel_linevar(train)
            -- vyplnit linevar_past:
            if train.line ~= nil and train.line ~= "" then
                ls.linevar_past = {
                    line = assert(linevar_def.line),
                    linevar = assert(linevar_def.name),
                    station = stn,
                    arrival = rwtime,
                }
            end
        end
    else
        -- linkový vlak zastavil na neznámé zastávce (nemělo by nastat)
        core.log("warning", "Train "..train_id.." of linevar '"..ls.linevar.."' stopped at unknown station '"..stn.."' at "..core.pos_to_string(pos).."!")
        debug_print("Vlak "..train_id.." je linkový vlak ("..ls.linevar.."), ale zastavil na sobě neznámé zastávce "..stn..", což by se nemělo stát.")
        can_start_line = false
    end

    -- ATC příkaz
    local atc_command = "B0 W O"..stdata.doors..(stdata.kick and "K" or "").." D"..wait..
        (stdata.keepopen and " " or " OC ")..(stdata.reverse and "R" or "").." D"..(stdata.ddelay or 1)..
        " A1 S" ..(stdata.speed or "M")
    advtrains.atc.train_set_command(train, atc_command, true)

    -- provést změny vlaku
    local new_line = stdata.line or ""
    local new_routingcode = stdata.routingcode or ""
    update_value(train, "line", new_line)
    update_value(train, "routingcode", new_routingcode)

    -- začít novou linku?
    if can_start_line and stn ~= nil and stn ~= "" and line_start(train, stn, planned_departure) then
        debug_print("Vlak "..train_id.." zahájil jízdu na nové lince ("..ls.linevar..") ze stanice "..stn..".")
        core.log("action", "Train "..train_id.." started a route with linevar '"..ls.linevar.."' at station '"..stn.."'.")
        train.text_inside = get_station_name(stn)
        assert(ls.linevar)
        linevar_def = assert(al.try_get_linevar_def(ls.linevar))
        local next_stop_index, next_stop_data = al.get_next_stop(linevar_def, 1)
        if next_stop_index ~= nil then
            train.text_inside = train.text_inside.."\nPříští zastávka/stanice: "..get_station_name(next_stop_data.stn)
            if next_stop_data.mode ~= nil and next_stop_data.mode == MODE_REQUEST_STOP then
                train.text_inside = train.text_inside.." (na znamení)"
            end
        end
    elseif not had_linevar and ls.linevar == nil then
        -- vlak, který nebyl a stále není linkový:
        train.text_inside = get_station_name(stn)
        -- core.after(wait, function() train.text_inside = "" end)
    end
end

function al.on_train_leave(pos, train_id, train, index)
    local pe = advtrains.encode_pos(pos)
    local stdata = advtrains.lines.stops[pe]
    if stdata == nil then
        return -- neplatná zastávka
    end
    local stn = stdata.stn or ""
    local ls, linevar_def = al.get_line_status(train)
    local rwtime = assert(rwt.to_secs(rwt.get_time()))

    if stn ~= "" then
        ls.last_leave = {stn = stn, encpos = pe, rwtime = rwtime}
        debug_print("Vlak "..train_id.." zaznamenán na odjezdu: "..stn.." "..core.pos_to_string(pos).." @ "..rwtime)
    end

    if ls.standing_at == pe then
        -- vlak stál v této dopravně
        ls.standing_at = nil
        if
            linevar_def == nil or ls.linevar_index == nil or
            linevar_def.stops[ls.linevar_index] == nil or
            (linevar_def.stops[ls.linevar_index].mode or MODE_NORMAL) ~= MODE_HIDDEN
        then
            ls.stop_request = nil -- zrušit stop_request při odjezdu ze zastávky, pokud není nekoncová skrytá
        end
        if stn ~= "" then
            debug_print("Vlak "..train_id.." odjel ze zastávky "..stn)
            if ls.linevar_last_dep ~= nil and ls.linevar_last_dep > rwtime then
                debug_print("Vlak "..train_id.." předčasně odjel z dopravny "..stn.." (zbývalo "..(ls.linevar_last_dep - rwtime).." sekund)")
                ls.linevar_last_dep = rwtime -- předčasný odjezd
                if ls.linevar_index == 1 then
                    ls.linevar_dep = rwtime
                end
            end
        else
            debug_print("Vlak "..train_id.." odjel z anonymní zastávky "..core.pos_to_string(pos)..".")
        end
        train.text_inside = ""
        if linevar_def ~= nil then
            -- linkový vlak:
            debug_print("Linkový vlak "..train_id.." odjel ze zastávky s indexem "..ls.linevar_index)
            if ls.linevar_index == 1 then
                -- odjezd z výchozí zastávky:
                local new_passage = {rwtime}
                if stdata.last_wait ~= nil then
                    new_passage.wait = stdata.last_wait
                end
                current_passages[train_id] = new_passage
                local passages_by_linevar = last_passages[ls.linevar]
                if passages_by_linevar == nil then
                    passages_by_linevar = {new_passage}
                    last_passages[ls.linevar] = passages_by_linevar
                else
                    while #passages_by_linevar >= 10 do
                        table.remove(passages_by_linevar, 1)
                    end
                    table.insert(passages_by_linevar, new_passage)
                end
            else
                -- odjezd z nácestné zastávky
                local current_passage = current_passages[train_id]
                if current_passage ~= nil then
                    current_passage[ls.linevar_index] = rwtime
                end
            end
            local next_stop_index, next_stop_data = al.get_next_stop(linevar_def, ls.linevar_index)
            if next_stop_index ~= nil then
                train.text_inside = al.get_stop_description(nil, next_stop_data)
            end
        end
    -- else
        --[[ průjezd?
        local stn = (stdata and stdata.stn) or ""
        if stn ~= "" then
            debug_print("Vlak "..train_id.." projel (odjezd) zastávkou "..stn..".")
        else
            debug_print("Vlak "..train_id.." projel (odjezd) anonymní zastávkou "..core.pos_to_string(pos)..".")
        end
        ]]
    end
end

function al.linevar_decompose(linevar)
    if linevar == nil then
        return nil, nil, nil
    end
    local parts = string.split(linevar, "/", true, 3)
    return parts[1], parts[2] or "", parts[3] or ""
end

--[[
    Vrací:
    a) pokud linevar existuje a má průjezdy:
        passages, stops:
        {{[1] = rwtime, ..., wait = int or nil}...}, {"kód", "název"}...}
    b) jinak:
        nil, nil
]]
function al.get_last_passages(linevar_def)
    local lp = last_passages[linevar_def.name]
    if linevar_def ~= nil and lp ~= nil and lp[1] ~= nil then
        local passages, stops = {}, {}
        for i, stop in ipairs(linevar_def.stops) do
            stops[i] = {stop.stn, get_station_name(stop.stn)}
        end
        for i = 1, #lp do
            passages[i] = table.copy(lp[i])
        end
        return passages, stops
    end
end

local function get_last_pos(line_status)
    assert(line_status)
    local last_enter, last_leave, standing_at = line_status.last_enter, line_status.last_leave, line_status.standing_at
    local last_pos, last_pos_type
    if last_enter ~= nil then
        last_pos, last_pos_type = last_enter, "enter"
        if standing_at ~= nil and standing_at == last_enter.encpos then
            last_pos_type = "standing"
        elseif last_leave ~= nil and last_leave.rwtime > last_enter.rwtime then
            last_pos, last_pos_type = last_leave, "leave"
        end
    elseif last_leave ~= nil then
        last_pos, last_pos_type = last_leave, "leave"
    else
        result.type = "none"
        return {type = "none"}
    end
    local result = {type = last_pos_type, last_pos = last_pos}
    if last_enter ~= nil then
        result.last_enter = last_enter
    end
    if last_leave ~= nil then
        result.last_leave = last_leave
    end
    return result
end

function al.get_last_pos_station_name(line_status)
    local result = get_last_pos(line_status)
    if result.type ~= "none" then
        return get_station_name(result.last_pos.stn)
    else
        return nil
    end
end

local function get_train_position(line_status, linevar_def, rwtime)
    if line_status ~= nil then
        local last_pos_info = get_last_pos(line_status)
        local last_pos = last_pos_info.last_pos
        if last_pos ~= nil then
            local result = "„"..get_station_name(last_pos.stn).."“"
            local delay_info = al.get_delay_description(line_status, linevar_def, rwtime)
            if last_pos_info.type ~= "standing" then
                result = result.." (před "..(rwtime - last_pos.rwtime).." sekundami)"
            end
            if delay_info.has_delay ~= nil then
                result = result.." ("..delay_info.text..")"
            end
            return result
        end
    end
    return "???"
end

--[[
local function prepare_prediction_for_dump(result)
    local x = {}
    for i, record in ipairs(result) do
        local y = table.copy(record)
        y.stdata = record.stdata.name
        if y.arr_linevar_def ~= nil then
            y.arr_linevar_def = y.arr_linevar_def.name
        end
        if y.dep_linevar_def ~= nil then
            y.dep_linevar_def = y.dep_linevar_def.name
        end
        x[i] = y
    end
    return x
end
]]

local function predict_train_continue(line, stn, rc, departure, result)
    if line == nil or line == "" then
        return
    end
    local linevar_def = al.try_get_linevar_def(line.."/"..stn.."/"..rc, stn)
    if linevar_def == nil then
        return
    end
    if #result == 0 then
        return
    end
    local stops = assert(linevar_def.stops)
    local last_record = result[#result]
    last_record.dep = departure
    last_record.dep_linevar_def = linevar_def
    last_record.dep_index = 1
    local index = 2
    while stops[index] ~= nil do
        local stop = stops[index]
        local stdata = advtrains.lines.stations[stop.stn]
        if stop.mode == MODE_FINAL or stop.mode == MODE_FINAL_CONTINUE or stop.mode == MODE_FINAL_HIDDEN then
            -- koncová zastávka
            local arr = departure + stop.dep
            local record = {
                stn = assert(stop.stn),
                track = stop.track or "",
                stdata = stdata,
                arr = arr,
                arr_linevar_def = linevar_def,
                arr_index = index,
                delay = 0,
                hidden = stop.mode == MODE_FINAL_HIDDEN,
            }
            table.insert(result, record)
            return
        elseif stop.mode ~= MODE_DISABLED then
            -- mezilehlá zastávka
            local dep = departure + stop.dep
            table.insert(result, {
                stn = assert(stop.stn),
                track = stop.track or "",
                stdata = stdata,
                arr = dep - (stop.wait or 10),
                arr_linevar_def = linevar_def,
                arr_index = index,
                dep = dep,
                dep_linevar_def = linevar_def,
                dep_index = index,
                delay = 0,
                hidden = stop.mode == MODE_HIDDEN,
            })
        end
        index = index + 1
    end
end

--[[
    Zadaný vlak musí být linkový.
    Vrací:
        {
            stn = string, track = string, delay = int,
            stdata = table or nil,
            dep = int or nil, dep_linevar_def = table or nil, dep_index = int or nil,
            arr = int or nil, arr_linevar_def = table or nil, arr_index = int or nil,
        }
]]
function al.predict_train(line_status, linevar_def, rwtime, allow_continue)
    assert(line_status)
    assert(linevar_def)
    local stops = linevar_def.stops
    local result = {}
    local index = assert(line_status.linevar_index)
    if rwtime == nil then
        rwtime = rwt.to_secs(rwt.get_time())
    end
    local delay_desc = al.get_delay_description(line_status, linevar_def, rwtime)
    local delay
    if delay_desc.has_delay then
        delay = delay_desc.delay
    else
        delay = 0
    end
    local departure = line_status.linevar_dep
    if line_status.standing_at ~= nil then
        -- vlak stojí na zastávce
        local stop = assert(stops[index])
        local stdata = advtrains.lines.stations[stop.stn]
        table.insert(result, {
            stn = line_status.linevar_last_stn,
            track = stop.track or "",
            stdata = stdata,
            dep = assert(line_status.linevar_last_dep),
            dep_linevar_def = assert(linevar_def),
            dep_index = index,
            -- arr = nil, arr_index = nil, arr_linevar_def = nil,
            delay = delay,
            hidden = stop.mode == MODE_HIDDEN
        })
    end
    index = index + 1
    while stops[index] ~= nil do
        local stop = stops[index]
        local stdata = advtrains.lines.stations[stop.stn]
        if stop.mode == MODE_FINAL or stop.mode == MODE_FINAL_CONTINUE or stop.mode == MODE_FINAL_HIDDEN then
            -- koncová zastávka
            local arr = departure + stop.dep + delay
            local record = {
                stn = assert(stop.stn),
                track = stop.track or "",
                stdata = stdata,
                arr = arr,
                arr_linevar_def = linevar_def,
                arr_index = index,
                delay = delay,
                hidden = stop.mode == MODE_FINAL_HIDDEN,
                final = true,
            }
            table.insert(result, record)
            if allow_continue and (linevar_def.continue_line or "") ~= "" and stop.mode == MODE_FINAL_CONTINUE then
                predict_train_continue(linevar_def.continue_line, stop.stn, linevar_def.continue_rc, arr + (stop.wait or 10), result)
            end
            break
        elseif stop.mode ~= MODE_DISABLED then
            -- mezilehlá zastávka
            local dep = departure + stop.dep + delay
            table.insert(result, {
                stn = assert(stop.stn),
                track = stop.track or "",
                stdata = stdata,
                arr = dep - (stop.wait or 10),
                arr_linevar_def = linevar_def,
                arr_index = index,
                dep = dep,
                dep_linevar_def = assert(linevar_def),
                dep_index = index,
                delay = delay,
                hidden = stop.mode == MODE_HIDDEN,
            })
        end
        index = index + 1
    end
    -- print("DEBUG: "..dump2({prediction = prepare_prediction_for_dump(result)}))
    return result
end

local function vlaky(param, past_trains_too)
    local result = {}
    if param:match("/") then
        return result -- parametr nesmí obsahovat '/'
    end
    local train_line_prefix
    if param ~= "" then
        train_line_prefix = param.."/"
    end
    local rwtime = rwt.to_secs(rwt.get_time())
    local players_per_train = {}
    local results = {}
    for player_name, train_id in pairs(advtrains.player_to_train_mapping) do
        results[train_id] = (results[train_id] or 0) + 1
    end
    for train_id, train in pairs(advtrains.trains) do
        local ls, linevar_def = al.get_line_status(train)
        if linevar_def ~= nil then
            if train_line_prefix == nil or train_line_prefix == ls.linevar:sub(1, #train_line_prefix) then
                local direction_index, direction_stop = al.get_terminus(linevar_def, ls.linevar_index, false)
                local direction = "???"
                if direction_index ~= nil then
                    direction = get_station_name(direction_stop.stn)
                end
                local s = "("..train_id..") ["..linevar_def.line.."] směr „"..direction.."“, poloha: "..
                    get_train_position(ls, linevar_def, rwtime)
                if results[train_id] ~= nil then
                    s = s.." ["..results[train_id].." cestující/ch]"
                end
                table.insert(results, {key = linevar_def.name.."/"..ls.linevar_index, value = s})
            end
        elseif past_trains_too and ls.linevar_past ~= nil and (train_line_prefix == nil or ls.linevar_past.line == param) then
            local age = rwtime - ls.linevar_past.arrival
            local s = "("..train_id..") ["..ls.linevar_past.line.."] služební, poloha: "..
                get_station_name(ls.linevar_past.station).." (před "..age.." sekundami)"
            if results[train_id] ~= nil then
                s = s.." ["..results[train_id].." cestující/ch]"
            end
            table.insert(results, {
                key = string.format("%s/~/%s/%05d", ls.linevar_past.line, ls.linevar_past.station, age),
                value = s,
            })
        end
    end
    table.sort(results, function(a, b) return a.key < b.key end)
    for i, v in ipairs(results) do
        result[i] = v.value
    end
    return result
end

-- příkaz /vlaky
local def = {
    params = "[linka]",
    description = "Vypíše všechny linkové vlaky na zadané lince (resp. na všech linkách)",
    privs = {},
    func = function(player_name, param)
        local result = vlaky(param, false)
        if #result == 0 then
            return false, "Nenalezen žádný odpovídající vlak."
        end
        return true, "Nalezeno "..#result.." vlaků:\n- "..table.concat(result, "\n- ")
    end,
}
core.register_chatcommand("vlaky", def)
def = {
    params = "[linka]",
    description = "Vypíše všechny linkové vlaky na zadané lince (resp. na všech linkách) a ty, které nedávno jízdu na lince ukončily",
    privs = {ch_registered_player = true},
    func = function(player_name, param)
        local result = vlaky(param, true)
        if #result == 0 then
            return false, "Nenalezen žádný odpovídající vlak."
        end
        return true, "Nalezeno "..#result.." vlaků:\n- "..table.concat(result, "\n- ")
    end,
}
core.register_chatcommand("vlaky+", def)

def = {
    -- params = "",
    description = "(pro ladění)",
    privs = {server = true},
    func = function(player_name, param)
        local train = advtrains.trains[param]
        if train == nil then
            return false, "Vlak "..param.." nenalezen!"
        end
        local line_status, linevar_def = al.get_line_status(train)
        if linevar_def == nil then
            return false, "Vlak "..param.." není linkový!"
        end
        -- function al.predict_train(line_status, linevar_def, rwtime, allow_continue)
        local rwtime = rwt.to_secs(rwt.get_time())
        local predictions = al.predict_train(line_status, linevar_def, rwtime, true)
        local result = {"----"}
        local s
        for i, record in ipairs(predictions) do
            local arr, dep
            if record.arr ~= nil then
                arr = "("..(record.arr - rwtime)..", lv="..record.arr_linevar_def.name..", i="..record.arr_index..")"
            else
                arr = "nil"
            end
            if record.dep ~= nil then
                dep  = "("..(record.dep - rwtime)..", lv="..record.dep_linevar_def.name..", i="..record.dep_index..")"
            else
                dep = "nil"
            end
            result[i + 1] = "- "..record.stn.." ["..record.track.."] arr="..arr.." dep="..dep.." delay="..record.delay
        end
        table.insert(result, "----")
        s = table.concat(result, "\n")
        print(s)
        core.chat_send_player(player_name, s)
        return true
    end,
}
core.register_chatcommand("jřád", def)
core.register_chatcommand("jrad", def)


context:
space:
mode: