Forma: TeamBracket

 -
- Acest modul va implementa {{TeamBracket}}
-
require ( „Modul: fără globali” )
local getArgs = require ( 'Modul: Argumente' ). getArgs

local p = {}
local yes_replies = { 'yes' , 'y' , 's' , 'yes' , 'yes' }
local no_replies = { 'n' , 'no' }
local debug = false

stil local = {
table = "border-style: none; font-size: 90%; margin: 1em 2em 1em 1em; border-collapse: separate; border-spacing: 0" ,
seed_cell = "background-color: # f2f2f2; border: 1px solid #aaa; text-align: center;" ,
team_cell = "background-color: # f2f2f2; border: 1px solid #aaa; text-align: left; padding: 0 2px" ,
score_cell = "background-color: # f9f9f9; border: 1px solid #aaa; text-align: center;" ,
header_third_place = "text-align: center; border: 1px solid #aaa; background-color: # f2f2f2" ,
header_cell = "text-align: center; border: 1px solid #aaa; background-color: # f2f2f2" ,
path_bottom = "border: 0 negru solid; border-bottom-width: 2px;" ,
path_rigth_top = "border: 0 black solid; border-top-width: 1px; border-right-width: 2px;" ,
path_right_bottom = "margine: 0 negru continuu ; margine-jos-lățime: 1 px; margine-dreapta-lățime: 2 px;" ,
path_top = "border: 0 black solid; border-top-width: 2px;" ,
group = "text-align: center" , 
winner = 'font-weight: bold' ,
first_place = 'fundal-culoare: # F7F6A8' ,
second_place = 'background-color: # DCE5E5' ,
third_place = 'fundal-culoare: # FFDAB9' ,
row_height = " 3px " , 
buffer_sx_width = "5px" ,
seed_width = "25px" ,
team_width = "150px" ,
score_width = "25px" ,
row_width = "10px"
}

dacă depanare atunci
stil . grup = stil . grup .. "; fundal-culoare: verde"
stil . path_bottom = stil . path_bottom .. "; fundal-culoare: # F08080"
stil . path_top = stil . path_top .. "; fundal-culoare: # F08080"
stil . cale_rigth_top = stil . path_rigth_top .. "; fundal-culoare: # F08080"
stil . path_right_bottom = stil . path_right_bottom .. "; fundal-culoare: # F08080"
Sfârșit

- [[================================================= ===============================
Returnează true dacă acul este lista cu fân, altfel returnează false
================================================== = ============================]]
funcție locală in_array ( ac , fân )
dacă acul == zero atunci returnează fals ; Sfârșit
pentru n , v în ipairs ( fân ), do
dacă v == ac, apoi reveniți la adevărat ; Sfârșit
Sfârșit
returnează fals ;
Sfârșit

- [[================================================= ===============================
Obiectiv pentru a genera un TeamBracket
- args: matrice de parametri trecuți modulului
================================================== = ============================]]
local TeamBracket = {}

function TeamBracket : new ( args )

auto local = {}
setmetatable ( self , { __index = TeamBracket ,
__tostring = function ( t ) return self : __tostring () end })

sinele . args = args
sinele . rounds = tonumber ( self . args [ 'rounds' ]) sau 2
sinele . teams = math.pow ( 2 , auto . runde )
sinele . compact = in_array ( self . args [ 'compact' ], yes_replies )
sinele . hideSeeds = in_array ( self . args [ 'semințe' ], no_replies )
sinele . showSeeds = in_array ( self . args [ 'semințe' ], yes_replies )
padding local = '% 0' .. (( auto . echipe < 10 ) și 1 sau 2 ) .. 'd'
sinele . argname_pattern = 'RD% d-% s' .. umplere
sinele . scorename_pattern = 'RD% d-scor' .. umplere
local autobold_par = self . args [ 'bold_winner' ] sau ''
sinele . bold_winner = not in_array ( autobold_par , no_replies )
sinele . low_winner = sine . bold_winner și ( autobold_par == 'low' ) 
sinele . medalii = self . bold_winner și nu in_array ( self . args [ 'medalii' ], fără răspunsuri )
- încărcați numărul de scoruri pentru fiecare rundă
sinele . scoruri = {}
scores_raw locală = sine. argumente . scoruri sau '1'
scoruri maxime locale = 1
pentru i , score_value in ipairs ( mw . text . split ( scores_raw , ',' )) do
sinele . scoruri [ i ] = număr ( scor_valor ) sau 1
dacă eul . scoruri [ i ] > max_scores apoi max_scores = self . scoruri [ i ] sfârșit
Sfârșit
local last_scores = self . scoruri [ # auto . scoruri ]
pentru i = # sine . scoruri + 1 , auto . rundele fac
sinele . scoruri [ i ] = last_scores
Sfârșit
dacă max_scores > 1 atunci
sinele . scorename_pattern = sine . scorename_pattern .. "-% d"
Sfârșit
- stil personalizat
stil . castigator = sine . argumente . stil_medal sau stil . câştigător
stil . first_place = sine . argumente . style_first_place sau style . primul loc
stil . al doilea loc = sine . argumente . style_second_place sau style . locul doi
stil . al treilea_loc = sine . argumente . style_third_place sau style . locul al treilea
stil . header_cell = sine . argumente . style_header sau stil . header_cell
stil . header_third_place = self . argumente . style_header_third_place sau style . header_third_place
stil . seed_width = self : getWidth ( 'seed' , stil . seed_width )
stil . team_width = self : getWidth ( „echipă” , stil . team_width )
stil . score_width = self : getWidth ( 'scor' , stil . score_width )
- setați semințele implicite pentru runda 1
dacă nu ( self . hideSeeds ) atunci
semințe locale = self : getSeeds ()
argname local
pentru i = 1 , tabel . getn ( semințe ) face
argname = self : getTeamArgName ( 1 , 'seed' , i )
dacă nu args [ argname ] atunci
args [ argname ] = semințe [ i ]
Sfârșit
Sfârșit
Sfârșit
sinele . tbl = mw . html. create ( 'tabel' ): cssText ( stil . tabel )
dacă in_array ( args [ 'nowrap' ], yes_replies ) atunci
sinele . tbl : css ( „spațiu alb” , „nowrap” )
Sfârșit
sinele . rânduri = { }
dacă eul . compact apoi sinele . tbl : attr ( 'cellpadding' , '0' ) end
sinele . last_element = {}
sinele . rânduri = {}
sinele . current_col = 0
sinele . not_draw_top = false
self : renderHeading ()
self : renderTree ()
întoarcere de sine
Sfârșit

- [[================================================= ===============================
- prăbușește obiectul într-un șir care conține codul wikic pentru a genera arborele
================================================== = ============================]]
funcție TeamBracket : __tostring ()
return tostring ( self . tbl )
Sfârșit

- [[================================================= ===============================
Generați valorile implicite ale semințelor
================================================== = ============================]]
funcție TeamBracket : getSeeds ()
semințe locale = { 1 , 2 }
număr local = 2
local before = false
pentru r = 2 , auto . rundele fac
local max = math.pow ( 2 , r )
pentru i = 1 , conta do
local pos = i * 2
dacă înainte de atunci pos = pos - 1 sfârșit
table.insert ( semințe , pos , max - semințe [ i * 2 - 1 ] + 1 )
 înainte = nu înainte
Sfârșit
count = count * 2
Sfârșit
returnează semințele
Sfârșit

- [[================================================= ===============================
Returnează valoarea parametrilor de lățime (seed-widt, score-width, team-width)
================================================== = ============================]]
funcție TeamBracket : getWidth ( param , implicit )
local arg = self . args [ param .. '-width' ]
în cazul în care nu arg apoi să se întoarcă la sfârșitul implicit
returnează arg .. (( tonumber ( arg ) și 'px' ) sau '' )
Sfârșit

- [[================================================= ===============================
Dacă până la rândul rând, coloana col-1 nu au fost adăugate elemente încă
o celulă goală din ultima coloană utilizată de rând.
Apoi actualizează numărul de coloane utilizate la poziția coloană + lățime
Lățimea implicită este 0
================================================== = ============================ -]]
funcție TeamBracket : addGap ( rând , col , lățime , debug_info )
lățime = lățime sau 1
dacă eul . last_element [ rând ] + 1 < cu then
local gap = tostring ( col - self . last_element [ rând ] - 1 )
local cell = auto . rânduri [ rând ]: tag ( 'td' ): css ( 'background-color' , ( debug și '# F5F5DC' ) sau '' ): attr ( 'colspan' , gap )
dacă depanare atunci
celulă : wikitext ( string.format ( '<div style = "text-align: center;" title = "rând =% d, coloană:% d, last_col =% d, lățime:% d, decalaj:% s, last_col_set :% d, rotund:% d, deb:% s "> informații </div> ' ,
rând , col , auto . last_element [ rând ], lățime , decalaj , col + lățime , auto . current_round , debug_info sau '' ))
Sfârșit
Sfârșit
sinele . last_element [ rând ] = col + lățime - 1 
Sfârșit

- [[================================================= ===============================
Returnează numele complet al parametrului „argname” al echipei „echipă” din runda „rundă”
De exemplu, getTeamArgName (1, 'seed', 3) returnează 'RD1-seed3' sau '' RD1-seed03 'dacă există
10 echipe sau mai multe
================================================== = ============================]]
funcție TeamBracket : getTeamArgName ( rundă , argname , echipă )
returnează string.format ( self . argname_pattern , round , argname , team )
Sfârșit

- [[================================================= ===============================
Returnează valoarea parametrului „argname” al echipei „echipă” din runda „rundă”,
De exemplu, getTeamArg (1, „seed”, 3) returnează valoarea parametrului „RD1-seed3”
================================================== = ============================]]
funcție TeamBracket : getTeamArg ( rundă , argname , echipă )
a reveni auto. args [ self : getTeamArgName ( rundă , argname , echipă )]
Sfârșit

- [[================================================= ===============================
Returnează valoarea scorului, având în vedere runda, poziția în rundă (echipă) și
întâlnire progresivă.
================================================== = ============================]]
funcție TeamBracket : getScoreArg ( rundă , echipă , scor )
a reveni auto. args [ string.format ( auto . model scorename_ , rundă , echipă , scor )]
Sfârșit

- [[================================================= ===============================
Returnează numele rotund „rotund” sau numele implicit al acestuia dacă nu este specificat.
================================================== = ============================]]
function TeamBracket : getRoundName ( round )
nume local = self . args [ „RD” .. rotund ]
dacă nume, apoi returnați sfârșitul numelui
local round_names = { "Final" , "Semi-finals" , "Quarter" , "Round of 16" }
local roundFromLast = self . runde - runda + 1
dacă roundFromLast < 5 atunci
returnează round_names [ roundFromLast ]
altfel
întoarceți- vă ( rundă ) .. "rundă"
Sfârșit
Sfârșit

- [[================================================= ===============================
Adaugă liniile grafice care unesc celulele pentru rândul index al
rotund rotund. sus și stânga indică dacă rândul trebuie generat respectiv
stânga sau sus
- rândul 1 = primul rând al meciului superior din care iese calea
- rândul 2 = primul rând al meciului inferior din care iese calea
- row_gap = lățimea căii
- col = coloană de unde începe calea
rândul 1 nul înseamnă că calea începe doar de la rândul 2 și invers. Dacă ambele sunt
nul funcția nu atrage nimic.
================================================== = ============================]]
funcție TeamBracket : addPath ( rândul1 , rândul2 , rândul_gap , următorul_match )

local col = self . current_col + self . lățime_curentă  
local half_gap = row_gap / 2
dacă nu ( rândul 1 sau rândul 2 ), atunci reveniți la sfârșit
sinele . render_match [ self . current_round + 1 ] [ next_match ] = true
- prima jumătate
dacă rândul 1 atunci 
sinele . rânduri [ rând1 + 1 ]: etichetă ( 'td' ): cssText ( stil . cale_bottom )
pentru r = rândul1 + 1 , rândul 1 + 3 se auto . last_element [ r ] = col end
pentru r = rândul1 + 4 , rândul1 + 4 + jumătate_gap - 1 faceți auto : addGap ( r , col , 1 , 'ap1' ) sfârșit
sinele . rânduri [ rând1 + 2 ]: etichetă ( „td” )
: attr ( ' rowpan ' , half_gap + 2 )
: cssText ( stil . cale_rigth_top )
Sfârșit
--a doua jumătate
dacă rândul 2 atunci
sinele . rânduri [ rând2 + 2 ]: etichetă ( 'td' ): cssText ( stil . cale_top )
pentru r = rândul2 , rândul2 + 2 fac auto . last_element [ r ] = col end
pentru r = rând2 - half_gap , rând2 - 1 faceți auto : addGap ( r , col , 1 , 'ap2' ) end
sinele . rânduri [ rând2 - half_gap ]: etichetă ( 'td' )
: attr ( ' rowpan ' , half_gap + 2 )
: cssText ( style . path_right_bottom )
Sfârșit
rând_mediu local
middle_row = (ROW1 și (ROW1 + 2 + half_gap)) sau (ROW2 - half_gap - 2)
pentru r = middle_row - 1 , middle_row + 2 do self : addGap ( r , col + 1 , 1 , 'ap3' ) end
- sine: addGap (middle_row, col + 1, 1, 'ap3')
--self: addGap (middle_row + 1, col + 1, 1, 'ap3')
sinele . rânduri [ middle_row ]: tag ( 'td' ): cssText ( style . path_bottom ): attr ( 'rowspan' , '2' )
sinele . rânduri [ middle_row + 2 ]: tag ( 'td' ): cssText ( style . path_top ): attr ( 'rowspan' , '2' )
Sfârșit

- [[---------------------------------------------- - -------------
Comparați valorile scorului și reveniți și întoarceți câștigătorul meciului
(echipă cu majoritatea victoriei, 0 paritate medie, 1 echipă primă victorie, 2
a doua echipă câștigă) și și matrice cu câștigător pentru scoruri simple (pentru
fiecare scor unic 0 paritate, 1 victorie în prima echipă, 2 victorie în echipa a doua.
-------------------------------------------------- ---------- -]]
funcție TeamBracket : getWinner ( first_team_number )
victories1 locale = 0
victories2 locale = 0
local score_results = {}
pentru i = 1 , sine . scoruri [ auto . current_round ] face
score1 locală = sine: getScore (. current_round auto, first_team_number, i)
score2 locală = sine: getScore (. auto current_round, first_team_number + 1, i)
dacă scor1 și scor2 atunci 
dacă scor1 ~ = scor2 atunci
câștigător local = scor1 > scor2
dacă eul . low_winner atunci câștigător = nu câștigător sfârșit
dacă învingător atunci 
victorii1 = victorii1 + 1
score_results [ i ] = 1
altfel 
victorii2 = victorii2 + 1
score_results [ i ] = 2
Sfârșit
Sfârșit
Sfârșit
score_results [ i ] = score_results [ i ] or 0
Sfârșit
dacă victorii1 == victorii2 atunci returnează 0 , scor_rezultate se încheie
dacă victorii1 > victorii2 atunci returnează 1 , scor_rezultate se încheie
returnează 2 , scor_rezultate
Sfârșit

- [[================================================= ===============================
Desenați celula pentru echipă.
- team_name: numele echipei
- team_numer: numărul echipei din secvența rotundă
- rând: rândul primei celule în care să atragă echipa
- top: adevărat dacă este prima echipă a meciului
- medalie: pentru a acorda medalia (1: aur, 2: argint, 0: par)
- score_results: rezultatul scorurilor individuale (1: câștigat de prima echipă, 2 câștigat de a doua, 3 par)
================================================== = ============================]]
funcție TeamBracket : renderTeam ( team_name , team_number , row , show_seed , top , medal , score_results , is_bye )

self : addGap ( rând , self . current_col , self . current_width , 'rt' )
self : addGap ( rând + 1 , self . current_col , self . current_width , 'rt' )
- celula de sămânță
dacă show_seed atunci
seedArg local = self : getTeamArg ( self . current_round , 'seed' , team_number )
local seedCell = auto . rânduri [ rând ]: tag ( 'td' ): attr ( 'linespan' , '2' ): cssText ( stil . seed_cell ): wikitext ( seedArg ): newline ()
dacă eul . not_draw_top apoi seedCell : css ( 'border-top-width' , '0' ) end
dacă eul . bold_winner și ( medal == 1 sau medal == 3 ) apoi 
seedCell : cssText ( stil . câștigător ) 
Sfârșit
Sfârșit
- celula echipei
local teamCell = auto . rânduri [ rând ]: tag ( 'td' ): attr ( 'linespan' , '2' ): cssText ( stil . team_cell ): wikitext ( team_name ): newline ()
--local teamCell = self.rows [rând]: tag ('td'): attr ('rowspan', '2'): cssText (style.team_cell): wikitext (tostring (seedArg)): newline ()
dacă nu show_seed și ( nu self . hideSeeds ) atunci
teamCell : attr ( 'colspan' , '2' )
Sfârșit
dacă eul . not_draw_top atunci
teamCell : css ( 'border-top-width' , '0' )
Sfârșit
dacă eul . bold_winner și ( medal == 1 sau medal == 3 ) apoi 
teamCell : cssText ( stil . câștigător ) 
Sfârșit
dacă eul . current_round == self . runde și medalie ~ = 0 și auto . medalii atunci
dacă medalie == 1 atunci
teamCell : cssText ( style . first_place )
elseif medal == 2 atunci
teamCell : cssText ( style . second_place )
elseif medal == 3 atunci
teamCell : cssText ( style . third_place )
Sfârșit
Sfârșit
- punctează celulele
pentru i = 1 , sine . scoruri [ auto . current_round ] face
locală scoreCell = sine. rânduri [ rând ]
: Etichetă ( „TD”)
: attr ( 'rowpan' , '2' )
: cssText ( stil . score_cell )
: wikitext ( self : getScoreArg ( self . current_round , team_number , i ))
: Newline ()
dacă eul . not_draw_top apoi scoreCell : css ( 'border-top-width' , '0' ) end
local pos = ( sus și 1 ) sau 2
dacă score_results [ i ] == pos atunci scoreCell : cssText ( stil . câștigător ) se termină
Sfârșit
sinele . not_draw_top = ( self . current_round == 1 ) și ( not self . not_draw_top )
Sfârșit

function TeamBracket : getScore ( round , team_number , i )
scor local = string.gsub ( self : getScoreArg ( round , team_number , i ) sau '' , '% D' , '' )
return tonumber ( scor )
Sfârșit

- [[================================================= ===============================
Manipulează un chibrit
- match_number: numărul meciului numărând din partea de sus (1, 2, 3, ...)
- row_base: primul rând al tabelului în care se desenează lotul
================================================== = ============================]]

funcție TeamBracket : renderMatch ( match_number , row_base )

- obțineți numele echipei meciului, verificați dacă nu sunt la revedere și setați self.not_draw_top
- să înregistreze dacă ar trebui trasată sau nu linia de sus a meciului
- returnează numele echipei și dacă este o revedere (adevărat) sau nu (fals)
funcția locală getTeams ( team_number1 , team_number2 )
local team_name1 = self : getTeamArg ( self . current_round , 'team' , team_number1 )
local team_name2 = self : getTeamArg ( self . current_round , 'team' , team_number2 )
dacă team_name1 == 'bye' sau team_name2 == 'bye' sau nu ( team_name1 și team_name2 ) atunci
sinele . not_draw_top = false
returnează '' , '' , adevărat
Sfârșit
returnează echipă_nume1 , echipă_nume2 , fals
Sfârșit

local team_number2 = match_number * 2 
local team_number1 = team_number2 - 1
local team_name1 , team_name2 , is_bye = getTeams ( team_number1 , team_number2 )
dacă is_bye atunci
dacă eul . render_match [ self . current_round ] [ match_number ] atunci
pentru r = baza_rând , baza_rând + 3 faceți 
self : addGap ( r , self . current_col , self . current_width , 'rm' )
Sfârșit
local cell = auto . rânduri [ rând_bază ]: etichetă ( 'td' )
: attr ( 'rowpan' , '2' )
: attr ( 'colspan' , self . current_width )
: cssText ( stil . cale_bottom )
dacă depanare, atunci celula : css ( „fundal-culoare” , „# ADD8E6” ) se termină
celula = self . rânduri [ rând_bază + 2 ]: etichetă ( „td” )
: attr ( 'rowpan' , '2' )
: attr ( 'colspan' , self . current_width )
: cssText ( style . path_top )
dacă depanare, atunci celula : css ( „fundal-culoare” , „# ADD8E6” ) se termină
returnează baza_rând
Sfârșit
întoarceți zero
Sfârșit
dacă rând_bază < auto . min_row_used apoi auto . min_row_used = end_base end
dacă rând_bază + 3 > auto . max_row_used apoi auto . max_row_used = row_base + 3 end
seedArg1 local = self : getTeamArg ( self . current_round , 'seed' , team_number1 )
local seedArg2 = self : getTeamArg ( self . current_round , 'seed' , team_number2 )
showSeed local = nu auto . hideSeeds și ( self . showSeeds
sau ( seedArg1 și seedArg1 ~ = '-' )
sau ( seedArg2 și seedArg2 ~ = '-' ))
câștigător local , scor_rezultate = 0 , {}
dacă eul . bold_winner atunci 
câștigător , scor_rezultate = self : getWinner ( team_number1 )
Sfârșit
medal2 locală = (câștigătorul == 1 și 2) sau (câștigătorul == 2 și 1) sau 0
self : renderTeam ( team_name1 , team_number1 , row_base , showSeed , true , winner , score_results , is_bye )
self : renderTeam ( team_name2 , team_number2 , row_base + 2 , showSeed , false , medal2 , score_results , is_bye )
returnează baza_rând
Sfârșit

- [[================================================= ===============================
Trageți finala pentru locul trei
--row: linie în care să începeți desenarea finalului
================================================== = ============================]]

funcție TeamBracket : render_final_3 ( rând )
local team_name1 = self : getTeamArg ( self . rounds , 'team' , 3 )
local team_name2 = self : getTeamArg ( self . rounds , 'team' , 4 )
dacă team_name1 == 'bye' sau team_name2 == 'bye' atunci
întoarceți zero
Sfârșit
local seedArg1 = self : getTeamArg ( self . rounds , 'seed' , 3 )
local seedArg2 = self : getTeamArg ( self . rounds , 'seed' , 4 )
showSeed local = nu auto . hideSeeds și ( self . showSeeds
sau ( seedArg1 și seedArg1 ~ = '-' )
sau ( seedArg2 și seedArg2 ~ = '-' ))
câștigător local , scor_rezultate = 0 , {}
dacă eul . bold_winner atunci 
câștigător , scor_rezultate = self : getWinner ( 3 )
Sfârșit
self : addGap ( rând , self . current_col , self . current_width , 'f3' )
dacă rândul + 4 > auto . max_row_used apoi auto . max_row_used = rând + 4 sfârșit
sinele . rânduri [ rând ]: etichetă ( 'td' )
: cssText ( stil . header_third_place )
: attr ( 'colspan' , self . current_width )
: wikitext ( self . args [ 'RD-finalina' ] sau "Finale locul 3" )
: Newline ()
medalie locală 1 = ( câștigător == 1 și 3 ) sau 0
medal2 locală = (câștigătorul == 2 și 3) sau 0
self : renderTeam ( team_name1 , 3 , rând + 2 , showSeed , true , medal1 , score_results )
self : renderTeam ( team_name2 , 4 , rând + 4 , showSeed , false , medal2 , score_results )
Sfârșit

funcție TeamBracket : AddGroup ( rând , număr_grup )
nume local = auto . args [string.format ( 'RD% d-grup% d', de sine. current_round, GROUP_NUMBER)]
dacă nume atunci
local span = self . current_col + self . lățime_curentă - 2
self : addGap ( rând , self . current_col , self . current_col + span , 'g' )
self : addGap ( rând + 1 , self . current_col , self . current_col + span , 'g' )
sinele . rânduri [ rând ]: etichetă ( 'td' )
: attr ( 'rowpan' , '2' )
: attr ( „colspan” , span )
: cssText ( stil . grup )
: wikitext ( nume )
: Newline ()
Sfârșit
Sfârșit

funcție TeamBracket : renderTree ()
funcție locală normal_gap ( rând_count , match_number )
returnare ( rând_count + 2 - match_number * 4 ) / match_number
Sfârșit

funcție locală compact_gap ( rând_count , match_number )
return ( număr_rând - 4 * număr_meci ) / număr_meci
Sfârșit

- creați 3 sau 1 rânduri pentru fiecare echipă
local row_count = self . echipe * 2 + ( auto . compact și 0 sau ( auto . echipe - 2 ))
sinele . min_row_used = count_count
sinele . max_row_used = 1
local gap_function = ( self . compact and compact_gap ) sau normal_gap
pentru i = 1 , rând_count faceți
sinele . rânduri [ i ] = mw . html. create ( 'tr' )
sinele . rânduri [ i ]: tag ( 'td' ): css ( 'înălțime' , stil . rând_altime ): wikitext ( depanare și i sau '' )
sinele . last_element [ i ] = 1
Sfârșit
sinele . current_col = 2
sinele . render_match = {}
sinele . render_match [ 1 ] = {}
pentru runda = 1 , auto . rundele fac
sinele . curent_rund = rotund
sinele . render_match [ round + 1 ] = {}
sinele . current_width = ( self . hideSeeds and 1 or 2 ) + self . scoruri [ runda ]
local match_number = math.pow ( 2 , auto . runde - rundă )
local gap = gap_function ( row_count , match_number )
local row_base = gap / 2 + ( self . compact și 1 sau 0 )
local group_number = 1
pentru n = 1 , match_number , 2 do
local match1 = self : renderMatch ( n , base_rând )
dacă rotund < sine . runde atunci
local match2 = self : renderMatch ( n + 1 , row_base + gap + 4 )
dacă nu de sine . compact și rotund % 4 == 1 atunci
self : AddGroup ( rând_bază + 4 , grup_număr )
group_number = group_number + 1
Sfârșit
auto: addPath (match1, match2, decalaj, (n + 1) / 2)
row_base = row_base + 2 * gap + 8
Sfârșit
Sfârșit
sinele . current_col = sine . current_col + self . lățime_curentă + 2
Sfârșit
local third_place = self : getTeamArg ( self . rounds , 'team' , 3 )
- dacă este adevărat, apoi întoarce sfârșitul third_place
dacă al treilea loc, atunci - semifinala locurilor 3 și 4
sinele . current_col = sine . current_col - auto . lățime_curentă - 2
local offset = gap_function ( row_count , 1 ) / 2 + ( self . compact și 1 sau 0 ) + 6
if offset + 5 > row_count atunci
pentru i = număr_rând + 1 , decalare + 5 faceți
sinele . rânduri [ i ] = mw . html. create ( 'tr' )
sinele . rânduri [ i ]: tag ( 'td' ): css ( 'înălțime' , stil . rând_altime ): wikitext ( depanare și i sau '' )
sinele . last_element [ i ] = 1
Sfârșit
Sfârșit
self : render_final_3 ( offset )
Sfârșit
pentru rând = sine . min_row_used , auto . max_row_used face
sinele . tbl : nod ( auto . rânduri [ rând ])
Sfârșit
Sfârșit

- [[================================================= ===============================
Desenați liniile de antet ale șablonului
================================================== = ============================]]
funcție TeamBracket : renderHeading ()
local titleRow = self . tbl : tag ( 'tr' )
local widthRow = self . tbl : tag ( 'tr' )
local blank_text = self . compact și '' sau '& nbsp;'
titleRow : tag ( 'td' )
număr de rânduri locale = 1
widthRow : tag ( 'td' )
: css ( „lățime” , stil . buffer_sx_width )
: css ( „înălțime” , „5 px” )
: wikitext ( depanare și rând_count sau '' )
row_count = row_count + 1
pentru runda = 1 , auto . rundele fac
local colspan = tostring (( self . hideSeeds and 1 or 2 ) + self . scoruri [ round ])
local teamCell = titleRow : tag ( 'td' )
: cssText ( stil . header_cell )
: attr ( 'colspan' , colspan )
: wikitext ( self : getRoundName ( round ))
: Newline ()
dacă nu de sine . hideSeeds atunci
widthRow : tag ( 'td' ): css ( 'width' , stil . seed_width ): wikitext ( depanare și rând_count sau blank_text )
row_count = row_count + 1
Sfârșit
teamCell = widthRow : tag ( 'td' ): css ( 'width' , style . team_width ): wikitext ( debug and row_count or blank_text )
row_count = row_count + 1
pentru i = 1 , sine . scoruri [ runda ] do
widthRow : tag ( 'td' ): css ( 'width' , stil . score_width ): wikitext ( depanare și rând_count sau blank_text )
row_count = row_count + 1
Sfârșit
dacă rotund < sine . runde atunci
titleRow : tag ( 'td' ): attr ( 'colspan' , '2' )
widthRow : tag ( 'td' ): css ( 'width' , style . row_width ): wikitext ( debug și row_count sau blank_text )
row_count = row_count + 1
widthRow : tag ( 'td' ): css ( 'width' , style . row_width ): wikitext ( debug și row_count sau blank_text )
row_count = row_count + 1
Sfârșit
Sfârșit
Sfârșit

- ================================================== ===============
- Funcție de interfață cu șabloane
- ================================================== ===============

funcția p. teamBracket ( cadru )
argumente locale = getArgs ( cadru , {
- dacă argumentul este o sămânță, îl returnează așa cum este, chiar dacă este gol, toate celelalte argumente sunt curate
valueFunc = funcție ( cheie , valoare )
în cazul în care nu valoarea zero , atunci a reveni la sfârșitul
if key : find ( "^ RD% d% d? -seed" ), apoi returnează valoarea end
valoare = mw . text . decupare ( valoare )
dacă valoarea == „“ , apoi a reveni la sfârșitul zero 
valoarea returnată
Sfârșit
}
)
dacă args [ 'depanare' ] atunci
debug = in_array ( args [ 'debug' ], yes_replies ) sau debug
Sfârșit
local team_bracket = TeamBracket : new ( args )
întoarcere înapoi (echipă_bracket)
Sfârșit

retur p