wiki.angis.net - Naudotojo indėlis [lt]

MediaWiki:Sidebar

2022-08-18T10:44:15Z

Aurum86:

MediaWiki:Sidebar

2022-08-18T10:43:37Z

Agnis veikėjai

2022-07-21T11:47:45Z

Aurum86:

Programavimo platformos Angis siužetas tęsiasi per visus 14 lygių, kuriuose pagrindiniai veikėjai yra:

* Slibinas, kurio vardas Drakas.
* Princesė, kurios vardas Leila.
* Princas, kurio vardas Henris.

Kiekviename lygyje su tavo pagalba skirtingi veikėjai turi įveikti skirtingas užduotis, tu turėsi:

# lygyje Princui padėti pasiekti Žirgą.
# lygyje sukurti nuotraukos filtrą.
# lygyje pataisyti sugedusią Golemo programą.
# lygyje išnaikinti visus kaukoliukus.
# lygyje išlaisvinti slibiną.
# lygyje Golemui iškelti padėką virš stogų.
# lygyje suprogramuoti slaptažodžio paklausimą.
# lygyje sunaikinti Golemą, bet nesusinaikinti pačiam.
# lygyje pribaigti kaukoliukų armiją.
# lygyje įrengti pilies menę.
# lygyje suprogramuoti žaidimą - “žirklės”, “popierius”, “akmuo”.
# lygyje padėti Princui išsikirsti deimantų.
# lygyje suprogramuoti burtų lentyną
# lygyje - finalas!

Sėkmės programuojant!

MediaWiki:Common.css

2022-01-06T21:29:15Z

Aurum86:

/** Čia įdėtas CSS bus taikomas visoms išvaizdoms */

/* Slepiam "Aptarimas" TAB'ą */
#ca-talk {
display: none !important;
}

MediaWiki:Common.css

2021-12-17T22:38:40Z

Aurum86: Puslapis keičiamas su „/** Čia įdėtas CSS bus taikomas visoms išvaizdoms */“

/** Čia įdėtas CSS bus taikomas visoms išvaizdoms */

MediaWiki:Vector.css

2021-12-17T22:37:46Z

Aurum86: Naujas puslapis: /* All CSS here will be loaded for users of the Vector skin */ body { background: #f8f8fb; } #mw-head { background: #615dfa; color: white; min-height: 80px; } #mw-head a...

/* All CSS here will be loaded for users of the Vector skin */
body {
background: #f8f8fb;
}

#mw-head {
background: #615dfa;
color: white;
min-height: 80px;
}

#mw-head a {
color: white;
}

#mw-head .vector-menu-tabs li.selected {
background: #5653df;
}

#mw-head .vector-menu-tabs li {
background: #615dfa;
}

#mw-head .vector-menu-tabs .selected a, .vector-menu-tabs .selected a:visited {
color: white;
}

#mw-head .vector-menu-tabs .new a, .vector-menu-tabs .new a:visited {
color: white;
}

#mw-head .vector-menu-tabs li a {
color: white;
}

#mw-head .vector-menu-tabs, #mw-head .vector-menu-tabs a, #mw-head .vector-menu-dropdown h3 {
background-image: -webkit-gradient(linear,left top, left bottom,color-stop(0, rgba(167,215,249,0)),to(#1d2333));
background-image: -o-linear-gradient(top,rgba(167,215,249,0) 0,#1d2333 100%);
background-image: linear-gradient(to bottom,rgba(167,215,249,0) 0,#1d2333 100%);
color: white;
}

#mv-head .vector-menu-dropdown h3 {
color: white;
}

#mv-head .menu .vector-menu-content-list {
background: #615dfa;
}

.vector-menu-dropdown .vector-menu-content-list {
background: #615dfa;
}

.vector-menu-dropdown .vector-menu-checkbox:checked ~ .vector-menu-content .vector-menu-content-list {
background: #615dfa;
border-bottom-right-radius: 5px;
border-bottom-left-radius: 5px;
border: 0;
}

#mw-panel {
border-radius: 12px;
width: 176px;
border-top-right-radius: 0;
border-top-left-radius: 0;
-webkit-box-shadow: 0px 1px 1px 0px #bfbfbf;
box-shadow: 0px 1px 1px 0px #bfbfbf;
padding: 27px;
background: white;
margin-top: 80px;
}

#content {
padding: 32px 28px;
border-radius: 12px;
background-color: white;
-webkit-box-shadow: 0 0 40px 0 rgb(94 92 154 / 6%);
box-shadow: 0 0 40px 0 rgb(94 92 154 / 6%);
position: relative;
max-width: 50em;
margin-top: 25px;
border: 0;
}

#searchInput::-webkit-input-placeholder {
color: #fbfbfb;
}

#searchInput {
color: white;
}

.mw-body h1, .mw-body-content h1, .mw-body-content h2 {
font-family: Rajdhani,sans-serif;
border: 0;
}

@media screen and (min-width: 1366px) {
#content {
margin-left: auto;
margin-right: auto;
}

#footer {
max-width: 600px;
margin-left: auto;
margin-right: auto;
}
}

@media screen and (min-width: 769px) and (max-width: 1365px) {
#content {
margin-left: 255px;
margin-right: 25px;
}
#footer {
margin-left: 255px;
}
}

@media screen and (max-width: 768px) {
#mw-panel {
width: 10em;
padding: 0;
}
}

Pagrindinis puslapis

2021-04-14T18:53:00Z

Aurum86: Pakeičiau nuorodas paveikslėliuose iš Angis.net į Angis.lrt.lt

{{#seo:
|title=Angies viki puslapis {{!}} Angis.net |description=Angis.net sukurta Python programavimo kalbos enciklopedija. Nieko nelauk ir skaityk, pildyk ir sužinok kaip kurti savo programas ir žaidimus!}}
{{#seo:|robots=index, dofollow}}

[[Vaizdas:Angis.net pirmasis puslapis.png|alt=Angis.lrt.lt pirmasis puslapis|miniatiūra|Angis.lrt.lt pirmasis puslapis]]
[[Vaizdas:Angis.net IDE.png|miniatiūra|Angis.lrt.lt programavimo aplinka: kodo redaktorius ir programos rezultatas.|alt=Angis.lrt.lt programavimo aplinka: kodo redaktorius ir programos rezultatas.]]
[[Vaizdas:Vaidzo filtrų pavyzdžiai.png|miniatiūra|Skirtingų vaizdo filtrų taikymo pavyzdžiai]]
[[Vaizdas:Animuotų spraitų pavyzdys.gif|miniatiūra|Animuotų 2D spraitų pavyzdys. Fėja - vienas iš standartinių platformos veikėjų.]]
[https://angis.lrt.lt/#/ Angis.lrt.lt] - programavimo platforma, skirta programuoti [https://www.python.org/ Python] programavimo kalba tiesiai interneto naršyklėje. Šioje platformoje integruotos programavimo bei paruošti resursai kurti 2D interaktyvias programas: [[kaip kurti žaidimus | žaidimus]], [[kaip kurti puslapius | interneto puslapius]], [[kaip kurti programas | taikomasias programas]]. Angies platforma pritaikyta lietuvių kalbai - šalia standartinės (angliškos) [[Python_sintaksė | Python sintaksės]], galima naudoti taip pat ir [[lietuviski_sinonimai | lietuviškus sinonimus]]: todėl programavimui anglų kalbos žinios nėra būtinos, o programos kodai lengviau suprantami lietuviškai.

Šioje platformoje sukurtas programas galima [[programų viešinimas | viešinti]] (t.y. dalintis, "bendrinti"). Taigi, Angis.lrt.lt platformoje sukurtas žaidimas automatiškai virsta online [[kaip kurti programas | žaidimu]], arba asmeniniu internetiniu [[kaip kurti puslapius | puslapiu]].

Platforma yra visiškai nemokama, prieinama internetu - papildomo diegimo kompiuteriuose nereikia (veikia naršyklėse). Platforma gali naudotis ir neregistruoti vartotojai, tačiau norint išsisaugoti savo sukurtą kodą arba [[programų viešinimas | dalintis]] suprogramuotais kūriniais, reikia susikurti nemokamą paskyrą.

==2D programavimas==
Angis programose galima programuoti:
*[[filtrai |vaizdo filtrus]]
*groti [[garsas | garsus]] (mp3)
*rodyti png, jpeg ir kitokius [[paveiksliukai | paveiksliukus]]
*[[daiktas |daiktus]] ir [[veikėjas | veikėjus]]
*rašyti [[rašymas | tekstą]]
*pelės valdymą
*klaviatūros valdymą
*spraitų animacijas
*teksto ir skaičių įvedimą
*laiko ir datų skaičiavimus

==Dalinimasis sukurtomis programomis==

Registruoti naudotojai gali dalintis savo sukurtomis Python programomis: jeigu tik programa parašyta be sintaksės klaidų, jos kopiją galima [[programų viešinimas | viešinti]] persiunčiant unikalią nuorodą draugams. Pagal gautą nuorodą paleidus programą / žaidimą, jo programinis išeities kodas nebus matomas (galima tik vykdyti, bet kodas nerodomas).

==Video pamokos==
Platformoje pateikiama [[mokomieji_resursai |video ir tekstinė medžiaga]] visiems, norintiems išmokti programuoti. Už naujos [[uzduotys |užduoties]] išsprendimą [[Taškų skaičiavimas sėkmingai įveikus lygį|gali gauti taškų]], priklausomai nuo to, kaip greitai išspręsi užduotį po jos atsiradimo.

==Programavimo kalba==
===Python sintaksė===
{{Main| Python sintaksė}}

Angis.lrt.lt palaiko praktiškai visą Python 3.sintaksę, kuri realizuota [https://skulpt.org Skulpt] versijoje.

Pilnas Python programavimo kalbos žodžių sąrašas yra [[Python sintaksė | šiame puslapyje]].

Skulpt suderinamumas su Python 2 ir Python 3 aprašytas [[Python_sintaksė#Suderinamumas_su_standartu | čia]].

===Lietuviška sintaksė===
{{Main| lietuviški sinonimai}}

Angies platformoje daugelis angliškų "standartinio Pitono" raktinių žodžių turi ir [[lietuviski_sinonimai | lietuviškus sinonimus]]. Tokiu būdu vienoje programoje galima rašyti "lietuvišku", arba visiškai "standartiniu anglišku" Python, arba maišant žodžius. Taip pat visiškai be pakeitimų veikia ir angliškos Python bibliotekos.

{| class="wikitable"
|+Išplėstinės sintaksės pavyzdžiai
|-
! scope="col" | Standartinis / angliškas raktažodis
! scope="col" | Lietuviškas sinonimas
! scope="col" | Programinis kodas
|-
|print
|rašyk
|
<code>print ( "labas" )</code>
''arba''
<code>rašyk ( "labas" )</code>
|-
|def
|komanda
|
<code>def pirmyn ( num ):</code>
''arba''
<code>komanda pirmyn ( num ):</code>
|-
|if
|jei / jeigu
|
<code>if a < 10:</code>
''arba''
<code>jei a < 10:</code>
''arba''
<code>jeigu a < 10:</code>
|}

Lietuviški sinonimai patogūs pradedantiems arba retai programuojantiems žmonėms, nes toks programinis kodas artimesnis įprastinei kalbai.

Žr. [[lietuviski_sinonimai | lietuviškų sinonimų sąrašą]].

===Klaidų pranešimai===
Platformos kūrėjai teigia, jog daug dėmesio skyrė keisdami kompiliatorių taip, kad klaidų pranešimai būtų kaip galima suprantamesni. Pavyzdžiui, vietoje standartinio "unterminated string constant" pranešama "greičiausiai trūksta uždaromųjų kabučių". Klaidų pranešimus ir jų paaiškinimus galima rasti [[Klaidų pranešimai | klaidų pranešimų]] puslapyje.

==Programavimo galimybės==
{{Main|Platformos moduliai}}

Angis.lrt.lt galima naudoti daugelį Python modulių, kurie yra Skulpt versijoje - pavyzdžiui, datetime ir kitus.

Papildomai, šioje platformoje sukurti papildomi moduliai specialiai internetinėms programoms kurti - [[Modulis angis|angis]] ir [[Modulis žaidimas|žaidimas]].

Angis.lrt.lt naudoja [https://pixijs.io Pixi5] Javascript animacijų variklį, tik pritaikytą Python kalbai / Angies platformai.

==Kūrėjai==
Platfoma sukurta [https://visma.com Visma] iniciatyva ir lėšomis, siekiant suteikti programavimo mokymosi priemones ir medžiagą visos Lietuvos vaikams.

Naudotojas:Aurum86/sandbox

2021-03-31T07:47:53Z

Aurum86: Naujas puslapis: testas

testas

Pagrindinis puslapis

2021-03-09T21:58:00Z

Aurum86:

{{#seo:|title=Angies viki puslapis | Angis.net}}
{{#seo:|description=Angis.net sukurta Python programavimo kalbos enciklopedija. Nieko nelauk ir skaityk, pildyk ir sužinok kaip kurti savo programas ir žaidimus!}}

[[Vaizdas:Angis.net pirmasis puslapis.png|alt=Angis.net pirmasis puslapis|miniatiūra|Angis.net pirmasis puslapis]]
[[Vaizdas:Angis.net IDE.png|miniatiūra|Angis . net programavimo aplinka : kodo redaktorius ir programos rezultatas.]]
[[Vaizdas:Vaidzo filtrų pavyzdžiai.png|miniatiūra|Skirtingų vaizdo filtrų taikymo pavyzdžiai]]
[[Vaizdas:Animuotų spraitų pavyzdys.gif|miniatiūra|Animuotų 2D spraitų pavyzdys. Fėja - vienas iš standartinių platformos veikėjų.]]
[https://angis.net Angis.net] - programavimo platforma, skirta programuoti [https://www.python.org/ Python] programavimo kalba tiesiai interneto naršyklėje. Šioje platformoje integruotos programavimo bei paruošti resursai kurti 2D interaktyvias programas: [[kaip kurti žaidimus | žaidimus]], [[kaip kurti puslapius | interneto puslapius]], [[kaip kurti programas | taikomasias programas]].
Angis.net pritaikyta lietuvių kalbai - šalia standartinės (angliškos) [[Python_sintaksė | Python sintaksės]], galima naudoti taip pat ir [[lietuviski_sinonimai | lietuviškus sinonimus]]: todėl programavimui anglų kalbos žinios nėra būtinos, o programos kodai lengviau suprantami lietuviškai.

Šioje platformoje sukurtas programas galima [[programų viešinimas | viešinti]] (t.y. dalintis, "bendrinti"). Taigi, Angis.net platformoje sukurtas žaidimas automatiškai virsta online [[kaip kurti programas | žaidimu]], arba asmeniniu internetiniu [[kaip kurti puslapius | puslapiu]].

Platforma yra visiškai nemokama, prieinama internetu - papildomo diegimo kompiuteriuose nereikia (veikia naršyklėse). Platforma gali naudotis ir neregistruoti vartotojai, tačiau norint išsisaugoti savo sukurtą kodą arba [[programų viešinimas | dalintis]] suprogramuotais kūriniais, reikia susikurti nemokamą paskyrą.

== 2D programavimas ==
Angis.net programose galima programuoti:
* [[filtrai |vaizdo filtrus]]
* groti [[garsas | garsus]] (mp3)
* rodyti png, jpeg ir kitokius [[paveiksliukai | paveiksliukus]]
* [[daiktas |daiktus]] ir [[veikėjas | veikėjus]]
* rašyti [[rašymas | tekstą]]
* pelės valdymą
* klaviatūros valdymą
* spraitų animacijas
* teksto ir skaičių įvedimą
* laiko ir datų skaičiavimus

== Dalinimasis sukurtomis programomis ==

Registruoti naudotojai gali dalintis savo sukurtomis Python programomis: jeigu tik programa parašyta be sintaksės klaidų, jos kopiją galima [[programų viešinimas | viešinti]] persiunčiant unikalią nuorodą draugams. Pagal gautą nuorodą paleidus programą / žaidimą, jo programinis išeities kodas nebus matomas (galima tik vykdyti, bet kodas nerodomas).

== Video pamokos ==
Platformoje pateikiama [[mokomieji_resursai |video ir tekstinė medžiaga]] visiems, norintiems išmokti programuoti. Už naujos [[uzduotys |užduoties]] išsprendimą [[Taškų skaičiavimas sėkmingai įveikus lygį|gali gauti taškų]], priklausomai nuo to, kaip greitai išspręsi užduotį po jos atsiradimo.

== Programavimo kalba ==
===Python sintaksė===
{{Main| Python sintaksė}}

Angis.net palaiko praktiškai visą Python 3.sintaksę, kuri realizuota [https://skulpt.org Skulpt] versijoje.

Pilnas Python programavimo kalbos žodžių sąrašas yra [[Python sintaksė | šiame puslapyje]].

Skulpt suderinamumas su Python 2 ir Python 3 aprašytas [[Python_sintaksė#Suderinamumas_su_standartu | čia]].

=== Lietuviška sintaksė ===
{{Main| lietuviški sinonimai}}

Angies platformoje daugelis angliškų "standartinio Pitono" raktinių žodžių turi ir [[lietuviski_sinonimai | lietuviškus sinonimus]]. Tokiu būdu vienoje programoje galima rašyti "lietuvišku", arba visiškai "standartiniu anglišku" Python, arba maišant žodžius. Taip pat visiškai be pakeitimų veikia ir angliškos Python bibliotekos.

{| class="wikitable"
|+Išplėstinės sintaksės pavyzdžiai
|-
! scope="col" | Standartinis / angliškas raktažodis
! scope="col" | Lietuviškas sinonimas
! scope="col" | Programinis kodas
|-
|print
|rašyk
|
<code>print ( "labas" )</code>
''arba''
<code>rašyk ( "labas" )</code>
|-
|def
|komanda
|
<code>def pirmyn ( num ):</code>
''arba''
<code>komanda pirmyn ( num ):</code>
|-
|if
|jei / jeigu
|
<code>if a < 10:</code>
''arba''
<code>jei a < 10:</code>
''arba''
<code>jeigu a < 10:</code>
|}

Lietuviški sinonimai patogūs pradedantiems arba retai programuojantiems žmonėms, nes toks programinis kodas artimesnis įprastinei kalbai.

Žr. [[lietuviski_sinonimai | lietuviškų sinonimų sąrašą]].

=== Klaidų pranešimai ===
Platformos kūrėjai teigia, jog daug dėmesio skyrė keisdami kompiliatorių taip, kad klaidų pranešimai būtų kaip galima suprantamesni. Pavyzdžiui, vietoje standartinio "unterminated string constant" pranešama "greičiausiai trūksta uždaromųjų kabučių". Klaidų pranešimus ir jų paaiškinimus galima rasti [[Klaidų pranešimai | klaidų pranešimų]] puslapyje.

== Programavimo galimybės ==
{{Main|Platformos moduliai}}

Angis.net galima naudoti daugelį Python modulių, kurie yra Skulpt versijoje - pavyzdžiui, datetime ir kitus.

Papildomai, šioje platformoje sukurti papildomi moduliai specialiai internetinėms programoms kurti - [[Modulis angis|angis]] ir [[Modulis žaidimas|žaidimas]].

Angis.net naudoja [https://pixijs.io Pixi5] Javascript animacijų variklį, tik pritaikytą Python kalbai / Angies platformai.

== Kūrėjai ==
Platfoma sukurta [https://visma.com Visma] iniciatyva ir lėšomis, siekiant suteikti programavimo mokymosi priemones ir medžiagą visos Lietuvos vaikams.

Pagrindinis puslapis

2021-03-09T21:42:55Z

Aurum86:

Pagrindinis puslapis

2021-03-01T21:21:20Z

Aurum86:

Pagrindinis puslapis

2021-03-01T21:12:44Z

Aurum86:

{{#seo:|title=Angies viki puslapis | Angis.net}}
{{#seo:|description=Angis.net sukurta Python programavimo kalbos enciklopedija. Nieko nelauk ir skaityk, pildyk ir sužinok kaip kurti savo programas ir žaidimus!}}
[[Vaizdas:Angis.net pirmasis puslapis.png|alt=Angis.net pirmasis puslapis|miniatiūra|Angis.net pirmasis puslapis]]
[[Vaizdas:Angis.net IDE.png|miniatiūra|Angis . net programavimo aplinka : kodo redaktorius ir programos rezultatas.]]
[[Vaizdas:Vaidzo filtrų pavyzdžiai.png|miniatiūra|Skirtingų vaizdo filtrų taikymo pavyzdžiai]]
[[Vaizdas:Animuotų spraitų pavyzdys.gif|miniatiūra|Animuotų 2D spraitų pavyzdys. Fėja - vienas iš standartinių platformos veikėjų.]]
[https://angis.net Angis.net] - programavimo platforma, skirta programuoti [https://www.python.org/ Python] programavimo kalba tiesiai interneto naršyklėje. Šioje platformoje integruotos programavimo bei paruošti resursai kurti 2D interaktyvias programas: [[kaip kurti žaidimus | žaidimus]], [[kaip kurti puslapius | interneto puslapius]], [[kaip kurti programas | taikomasias programas]].
Angis.net pritaikyta lietuvių kalbai - šalia standartinės (angliškos) [[Python_sintaksė | Python sintaksės]], galima naudoti taip pat ir [[lietuviski_sinonimai | lietuviškus sinonimus]]: todėl programavimui anglų kalbos žinios nėra būtinos, o programos kodai lengviau suprantami lietuviškai.

Šioje platformoje sukurtas programas galima [[programų viešinimas | viešinti]] (t.y. dalintis, "bendrinti"). Taigi, Angis.net platformoje sukurtas žaidimas automatiškai virsta online [[kaip kurti programas | žaidimu]], arba asmeniniu internetiniu [[kaip kurti puslapius | puslapiu]].

Platforma yra visiškai nemokama, prieinama internetu - papildomo diegimo kompiuteriuose nereikia (veikia naršyklėse). Platforma gali naudotis ir neregistruoti vartotojai, tačiau norint išsisaugoti savo sukurtą kodą arba [[programų viešinimas | dalintis]] suprogramuotais kūriniais, reikia susikurti nemokamą paskyrą.

== 2D programavimas ==
Angis.net programose galima programuoti:
* [[filtrai |vaizdo filtrus]]
* groti [[garsas | garsus]] (mp3)
* rodyti png, jpeg ir kitokius [[paveiksliukai | paveiksliukus]]
* [[daiktas |daiktus]] ir [[veikėjas | veikėjus]]
* rašyti [[rašymas | tekstą]]
* pelės valdymą
* klaviatūros valdymą
* spraitų animacijas
* teksto ir skaičių įvedimą
* laiko ir datų skaičiavimus

== Dalinimasis sukurtomis programomis ==

Registruoti naudotojai gali dalintis savo sukurtomis Python programomis: jeigu tik programa parašyta be sintaksės klaidų, jos kopiją galima [[programų viešinimas | viešinti]] persiunčiant unikalią nuorodą draugams. Pagal gautą nuorodą paleidus programą / žaidimą, jo programinis išeities kodas nebus matomas (galima tik vykdyti, bet kodas nerodomas).

== Video pamokos ==
Platformoje pateikiama [[mokomieji_resursai |video ir tekstinė medžiaga]] visiems, norintiems išmokti programuoti. Už naujos [[uzduotys |užduoties]] išsprendimą [[Taškų skaičiavimas sėkmingai įveikus lygį|gali gauti taškų]], priklausomai nuo to, kaip greitai išspręsi užduotį po jos atsiradimo.

== Programavimo kalba ==
===Python sintaksė===
{{Main| Python sintaksė}}

Angis.net palaiko praktiškai visą Python 3.sintaksę, kuri realizuota [https://skulpt.org Skulpt] versijoje.

Pilnas Python programavimo kalbos žodžių sąrašas yra [[Python sintaksė | šiame puslapyje]].

Skulpt suderinamumas su Python 2 ir Python 3 aprašytas [[Python_sintaksė#Suderinamumas_su_standartu | čia]].

=== Lietuviška sintaksė ===
{{Main| lietuviški sinonimai}}

Angies platformoje daugelis angliškų "standartinio Pitono" raktinių žodžių turi ir [[lietuviski_sinonimai | lietuviškus sinonimus]]. Tokiu būdu vienoje programoje galima rašyti "lietuvišku", arba visiškai "standartiniu anglišku" Python, arba maišant žodžius. Taip pat visiškai be pakeitimų veikia ir angliškos Python bibliotekos.

{| class="wikitable"
|+Išplėstinės sintaksės pavyzdžiai
|-
! scope="col" | Standartinis / angliškas raktažodis
! scope="col" | Lietuviškas sinonimas
! scope="col" | Programinis kodas
|-
|print
|rašyk
|
<code>print ( "labas" )</code>
''arba''
<code>rašyk ( "labas" )</code>
|-
|def
|komanda
|
<code>def pirmyn ( num ):</code>
''arba''
<code>komanda pirmyn ( num ):</code>
|-
|if
|jei / jeigu
|
<code>if a < 10:</code>
''arba''
<code>jei a < 10:</code>
''arba''
<code>jeigu a < 10:</code>
|}

Lietuviški sinonimai patogūs pradedantiems arba retai programuojantiems žmonėms, nes toks programinis kodas artimesnis įprastinei kalbai.

Žr. [[lietuviski_sinonimai | lietuviškų sinonimų sąrašą]].

=== Klaidų pranešimai ===
Platformos kūrėjai teigia, jog daug dėmesio skyrė keisdami kompiliatorių taip, kad klaidų pranešimai būtų kaip galima suprantamesni. Pavyzdžiui, vietoje standartinio "unterminated string constant" pranešama "greičiausiai trūksta uždaromųjų kabučių". Klaidų pranešimus ir jų paaiškinimus galima rasti [[Klaidų pranešimai | klaidų pranešimų]] puslapyje.

== Programavimo galimybės ==
{{Main|Platformos moduliai}}

Angis.net galima naudoti daugelį Python modulių, kurie yra Skulpt versijoje - pavyzdžiui, datetime ir kitus.

Papildomai, šioje platformoje sukurti papildomi moduliai specialiai internetinėms programoms kurti - [[Modulis angis|angis]] ir [[Modulis žaidimas|žaidimas]].

Angis.net naudoja [https://pixijs.io Pixi5] Javascript animacijų variklį, tik pritaikytą Python kalbai / Angies platformai.

== Kūrėjai ==
Platfoma sukurta [https://visma.com Visma] iniciatyva ir lėšomis, siekiant suteikti programavimo mokymosi priemones ir medžiagą visos Lietuvos vaikams.

Pagrindinis puslapis

2021-03-01T20:16:57Z

Aurum86:

Šablonas:Main/doc

2020-12-22T21:46:31Z

Aurum86:

{{TemplateData header}}
<templatedata>
{
"description": "This template is used after the heading of a section, to link to a sub-article (or sub-articles) that is entirely about the topic of the section. The template will display, in italics, \"Main article: Article 1, Article 2 and Article 3\"",
"params": {
"1": {
"label": "Page 1",
"description": "The name of the first page that you want to link to. If this is not specified, the current page name (with no namespace prefix) is used instead. ",
"type": "wiki-page-name",
"required": false,
"suggested": true
},
"2": {
"label": "Page 2",
"description": "The name of the second page that you want to link to.",
"type": "wiki-page-name",
"required": false
},
"3": {
"label": "Page 3",
"description": "The name of the third page that you want to link to. More pages can be added using the parameters \"4\", \"5\", etc.",
"type": "wiki-page-name",
"required": false
},
"l1": {
"type": "string",
"label": "Label 1",
"description": "What the first linked page is to be displayed as.",
"aliases": [
"label 1"
]
},
"l2": {
"label": "Label 2",
"description": "What the second linked page is to be displayed as.",
"type": "string",
"aliases": [
"label 2"
]
},
"l3": {
"label": "Label 3",
"description": "What the third linked page is to be displayed as. Other labels can be added by using increasing numbers (starting with \"l4\" for page 4) as parameter names.",
"type": "string",
"aliases": [
"label 3"
]
},
"selfref": {
"type": "boolean",
"label": "Self reference",
"description": "Set to \"yes\" if the template is a self-reference to Wikipedia that would not make sense on mirrors or forks of the Wikipedia site."
}
},
"paramOrder": [
"1",
"2",
"3",
"l1",
"l2",
"l3",
"selfref"
],
"format": "{{_|_ = _}}\n"
}
</templatedata>

Šablonas:Main/doc

2020-12-22T21:46:17Z

Aurum86:

Šablonas:Main/doc

2020-12-22T21:38:32Z

Aurum86:

<templatedata>
{
"description": "This template is used after the heading of a section, to link to a sub-article (or sub-articles) that is entirely about the topic of the section. The template will display, in italics, \"Main article: Article 1, Article 2 and Article 3\"",
"params": {
"1": {
"label": "Page 1",
"description": "The name of the first page that you want to link to. If this is not specified, the current page name (with no namespace prefix) is used instead. ",
"type": "wiki-page-name",
"required": false,
"suggested": true
},
"2": {
"label": "Page 2",
"description": "The name of the second page that you want to link to.",
"type": "wiki-page-name",
"required": false
},
"3": {
"label": "Page 3",
"description": "The name of the third page that you want to link to. More pages can be added using the parameters \"4\", \"5\", etc.",
"type": "wiki-page-name",
"required": false
},
"l1": {
"type": "string",
"label": "Label 1",
"description": "What the first linked page is to be displayed as.",
"aliases": [
"label 1"
]
},
"l2": {
"label": "Label 2",
"description": "What the second linked page is to be displayed as.",
"type": "string",
"aliases": [
"label 2"
]
},
"l3": {
"label": "Label 3",
"description": "What the third linked page is to be displayed as. Other labels can be added by using increasing numbers (starting with \"l4\" for page 4) as parameter names.",
"type": "string",
"aliases": [
"label 3"
]
},
"selfref": {
"type": "boolean",
"label": "Self reference",
"description": "Set to \"yes\" if the template is a self-reference to Wikipedia that would not make sense on mirrors or forks of the Wikipedia site."
}
},
"paramOrder": [
"1",
"2",
"3",
"l1",
"l2",
"l3",
"selfref"
],
"format": "{{_|_ = _}}\n"
}
</templatedata>

Šablonas:Main/doc

2020-12-22T21:38:09Z

Aurum86: Naujas puslapis: <templatedata> { "description": "This template is used after the heading of a section, to link to a sub-article (or sub-articles) that is entirely about the topic of the section...

Pagrindinis puslapis

2020-12-16T22:42:44Z

Aurum86: /* 2D ir animacijų programavimas */

[https://angis.net Angis . net] - programavimo platforma, kur galima programuoti naudojant tiek standartinę [[python|Python]], tiek ir išplėstinę [[lietuviska_python_versija|lietuvišką python]] sintaksę.

Ši platforma yra visiškai nemokama, prieinama internetu - papildomo diegimo kompiuteriuose nereikia (veikia naršyklėse). Platforma gali naudotis ir neregistruoti vartotojai, tačiau norint išsisaugoti savo sukurtą kodą arba [[programu_viesinimas | dalintis]] suprogramuotais kūriniais, reikia susikurti nemokamą paskyrą.

Platformoje pateikiama [[mokomieji_resursai | video ir tekstinė medžiaga]] nariams, norintiems išmokti programuoti. Už naujos [[uzduotys | užduoties]] išsprendimą registruoti nariai [[tasku_sistema | gali gauti taškų]] (jei užduotis išsprendžiama pakankamai greitai po išleidimo).

== Programavimo kalba ==
===Python sintaksė===
([[Python_sintaksė | daugiau žr Python sintaksė]])

Angis.net palaiko praktiškai visą Python 3.sintaksę, kuri realizuota [https://skulpt.org Skulpt] versijoje.

Pilnas Python programavimo kalbos žodžių sąrašas yra [[python_sintakse | šiame puslapyje]].

Skulpt suderinamumas su Python 2 ir Python 3 aprašytas [[suderinamumas_su_python_2_ir_3 | čia]].

=== Lietuviška sintaksė ===
{{Main| lietuviški sinonimai}}

Angies platformoje daugelis angliškų "standartinio Pitono" raktinių žodžių turi ir [[lietuviski_sinonimai | lietuviškus sinonimus]]. Tokiu būdu vienoje programoje galima rašyti grynai "lietuvišku", arba visiškai "standartiniu anglišku" Python, arba maišant žodžius. Taip pat visiškai be pakeitimų veikia ir angliškos Python bibliotekos.

{| class="wikitable"
|+Išplėstinės sintaksės pavyzdžiai
|-
! scope="col" | Standartinis / angliškas raktažodis
! scope="col" | Lietuviškas sinonimas
! scope="col" | Programinis kodas
|-
|print
|rašyk
|
<code>print ( "labas" )</code>
''arba''
<code>rašyk ( "labas" )</code>
|-
|def
|komanda
|
<code>def pirmyn ( num ):</code>
''arba''
<code>komanda pirmyn ( num ):</code>
|-
|if
|jei / jeigu
|
<code>if a < 10:</code>
''arba''
<code>jei a < 10:</code>
''arba''
<code>jeigu a < 10:</code>
|}

Lietuviški sinonimai patogūs pradedantiems arba nedažnai programuojantiems žmonėms, nes toks programinis kodas artimesnis įprastinei kalbai.

Žr. [[lietuviski_sinonimai | lietuviškų sinonimų sąrašą]].

=== Klaidų pranešimai ===

Platformos kūrėjai teigia, jog daug dėmesio skyrė perdarinėdami kompiliatorių taip, kad klaidų pranešimai būtų kaip galima suprantamesni. Pavyzdžiui, vietoje standartinio "unterminated string constant" pranešama "greičiausiai trūksta uždaromųjų kabučių."

== 2D ir animacijų programavimas ==
{{Main| Pixi.js API}}

Angis.net naudoja [https://pixijs.io Pixi5] Javascript animacijų variklį, tik pritaikytą Python kalbai / Angies platformai. Vartotojai gali susikurti [[animacija | 2D spraitų animacijas]], kurti [[klaviaturos_komandos | klaviatūra]] ar [[peles_komandos | pele]] valdomus žaidimus, animuotus [[puslapiu_programavimas | puslapius]], ir kitus programinius sprendimus, kurie veikia naršyklėse (Javascript + HTML5).

Platformoje yra standartinių [[standartines_animacijos | animacijų]], [[standartiniai_paveiksleliai | paveikslėlių]] ir [[ standartiniai_veikejai | veikėjų]]; taip pat standartinių [[standartiniai_garsai | garsų]]. Šiais resursais naudojantis, patogu išbandyti platformos galimybes. Registruoti vartotojai gali susikelti ir savo vaizdo bei garso [[vartotoj_resursai | resursus]].

== Dalinimasis sukurtomis programomis ==

Registruoti naudotojai gali dalintis savo sukurtomis Python programomis: jeigu tik programa parašyta be sintaksės klaidų, jos kopiją galima [[programu_viesinimas | viešinti]] persiunčiant unikalią nuorodą draugams. Pagal gautą nuorodą paleidus programą / žaidimą, jo programinis išeities kodas nebus matomas (galima tik vykdyti, bet kodas nerodomas).

== Kūrėjai ==

Platfoma sukurta [https://visma.com Visma] iniciatyva ir lėšomis, siekiant suteikti programavimo mokymosi priemones ir medžiagą visos Lietuvos vaikams.

Pagrindinis puslapis

2020-12-16T22:42:09Z

Aurum86: /* Lietuviška sintaksė */

[https://angis.net Angis . net] - programavimo platforma, kur galima programuoti naudojant tiek standartinę [[python|Python]], tiek ir išplėstinę [[lietuviska_python_versija|lietuvišką python]] sintaksę.

Ši platforma yra visiškai nemokama, prieinama internetu - papildomo diegimo kompiuteriuose nereikia (veikia naršyklėse). Platforma gali naudotis ir neregistruoti vartotojai, tačiau norint išsisaugoti savo sukurtą kodą arba [[programu_viesinimas | dalintis]] suprogramuotais kūriniais, reikia susikurti nemokamą paskyrą.

Platformoje pateikiama [[mokomieji_resursai | video ir tekstinė medžiaga]] nariams, norintiems išmokti programuoti. Už naujos [[uzduotys | užduoties]] išsprendimą registruoti nariai [[tasku_sistema | gali gauti taškų]] (jei užduotis išsprendžiama pakankamai greitai po išleidimo).

== Programavimo kalba ==
===Python sintaksė===
([[Python_sintaksė | daugiau žr Python sintaksė]])

Angis.net palaiko praktiškai visą Python 3.sintaksę, kuri realizuota [https://skulpt.org Skulpt] versijoje.

Pilnas Python programavimo kalbos žodžių sąrašas yra [[python_sintakse | šiame puslapyje]].

Skulpt suderinamumas su Python 2 ir Python 3 aprašytas [[suderinamumas_su_python_2_ir_3 | čia]].

=== Lietuviška sintaksė ===
{{Main| lietuviški sinonimai}}

Angies platformoje daugelis angliškų "standartinio Pitono" raktinių žodžių turi ir [[lietuviski_sinonimai | lietuviškus sinonimus]]. Tokiu būdu vienoje programoje galima rašyti grynai "lietuvišku", arba visiškai "standartiniu anglišku" Python, arba maišant žodžius. Taip pat visiškai be pakeitimų veikia ir angliškos Python bibliotekos.

{| class="wikitable"
|+Išplėstinės sintaksės pavyzdžiai
|-
! scope="col" | Standartinis / angliškas raktažodis
! scope="col" | Lietuviškas sinonimas
! scope="col" | Programinis kodas
|-
|print
|rašyk
|
<code>print ( "labas" )</code>
''arba''
<code>rašyk ( "labas" )</code>
|-
|def
|komanda
|
<code>def pirmyn ( num ):</code>
''arba''
<code>komanda pirmyn ( num ):</code>
|-
|if
|jei / jeigu
|
<code>if a < 10:</code>
''arba''
<code>jei a < 10:</code>
''arba''
<code>jeigu a < 10:</code>
|}

Lietuviški sinonimai patogūs pradedantiems arba nedažnai programuojantiems žmonėms, nes toks programinis kodas artimesnis įprastinei kalbai.

Žr. [[lietuviski_sinonimai | lietuviškų sinonimų sąrašą]].

=== Klaidų pranešimai ===

Platformos kūrėjai teigia, jog daug dėmesio skyrė perdarinėdami kompiliatorių taip, kad klaidų pranešimai būtų kaip galima suprantamesni. Pavyzdžiui, vietoje standartinio "unterminated string constant" pranešama "greičiausiai trūksta uždaromųjų kabučių."

== 2D ir animacijų programavimas ==
{{Main: Pixi.js API}}

Angis.net naudoja [https://pixijs.io Pixi5] Javascript animacijų variklį, tik pritaikytą Python kalbai / Angies platformai. Vartotojai gali susikurti [[animacija | 2D spraitų animacijas]], kurti [[klaviaturos_komandos | klaviatūra]] ar [[peles_komandos | pele]] valdomus žaidimus, animuotus [[puslapiu_programavimas | puslapius]], ir kitus programinius sprendimus, kurie veikia naršyklėse (Javascript + HTML5).

Platformoje yra standartinių [[standartines_animacijos | animacijų]], [[standartiniai_paveiksleliai | paveikslėlių]] ir [[ standartiniai_veikejai | veikėjų]]; taip pat standartinių [[standartiniai_garsai | garsų]]. Šiais resursais naudojantis, patogu išbandyti platformos galimybes. Registruoti vartotojai gali susikelti ir savo vaizdo bei garso [[vartotoj_resursai | resursus]].

== Dalinimasis sukurtomis programomis ==

Registruoti naudotojai gali dalintis savo sukurtomis Python programomis: jeigu tik programa parašyta be sintaksės klaidų, jos kopiją galima [[programu_viesinimas | viešinti]] persiunčiant unikalią nuorodą draugams. Pagal gautą nuorodą paleidus programą / žaidimą, jo programinis išeities kodas nebus matomas (galima tik vykdyti, bet kodas nerodomas).

== Kūrėjai ==

Platfoma sukurta [https://visma.com Visma] iniciatyva ir lėšomis, siekiant suteikti programavimo mokymosi priemones ir medžiagą visos Lietuvos vaikams.

Module:Main

2020-12-16T22:40:19Z

Aurum86:

--[[
-- This module produces a link to a main article or articles. It implements the
-- template {{main}}.
--
-- If the module is used in category or category talk space, it produces "The
-- main article for this category is xxx." Otherwise, it produces
-- "Main article: xxx".
--]]

local mHatnote = require('Module:Hatnote')
local mHatlist = require('Module:Hatnote list')
local mArguments -- lazily initialise
local p = {}

function p.main(frame)
mArguments = require('Module:Arguments')
local args = mArguments.getArgs(frame, {parentOnly = true})
local pages = {}
for k, v in pairs(args) do
if type(k) == 'number' then
local display = args['label ' .. k] or args['l' .. k]
local page = display and
string.format('%s|%s', string.gsub(v, '|.*$', ''), display) or v
pages[#pages + 1] = page
end
end
if #pages == 0 and mw.title.getCurrentTitle().namespace == 0 then
return mHatnote.makeWikitextError(
'no page names specified',
'Template:Main#Errors',
args.category
)
end
local options = {
selfref = args.selfref
}
return p._main(pages, options)
end

function p._main(args, options)
-- Get the list of pages. If no first page was specified we use the current
-- page name.
local currentTitle = mw.title.getCurrentTitle()
if #args == 0 then args = {currentTitle.text} end
local firstPage = string.gsub(args[1], '|.*$', '')
-- Find the pagetype.
local pageType = mHatnote.findNamespaceId(firstPage) == 0 and 'straipsnis' or 'puslapis'
-- Make the formatted link text
list = mHatlist.andList(args, true)
-- Build the text.
local isPlural = #args > 1
local mainForm
local curNs = currentTitle.namespace
if (curNs == 14) or (curNs == 15) then --category/talk namespaces
mainForm = isPlural and
'The main %ss for this [[Help:Categories|category]] are %s.'
or
'The main %s for this [[Help:Categories|category]] is %s.'
else
mainForm = isPlural and 'Pagrindinis %ss: %s' or 'Pagrindinis %s: %s'
end
local text = string.format(mainForm, pageType, list)
-- Process the options and pass the text to the _rellink function in
-- [[Module:Hatnote]].
options = options or {}
local hnOptions = {
selfref = options.selfref
}
return mHatnote._hatnote(text, hnOptions)
end

return p

Module:Arguments

2020-12-16T22:33:21Z

Aurum86: Naujas puslapis: -- This module provides easy processing of arguments passed to Scribunto from -- #invoke. It is intended for use by other Lua modules, and should not be -- called from #invoke di...

-- This module provides easy processing of arguments passed to Scribunto from
-- #invoke. It is intended for use by other Lua modules, and should not be
-- called from #invoke directly.

local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType

local arguments = {}

-- Generate four different tidyVal functions, so that we don't have to check the
-- options every time we call it.

local function tidyValDefault(key, val)
if type(val) == 'string' then
val = val:match('^%s*(.-)%s*$')
if val == '' then
return nil
else
return val
end
else
return val
end
end

local function tidyValTrimOnly(key, val)
if type(val) == 'string' then
return val:match('^%s*(.-)%s*$')
else
return val
end
end

local function tidyValRemoveBlanksOnly(key, val)
if type(val) == 'string' then
if val:find('%S') then
return val
else
return nil
end
else
return val
end
end

local function tidyValNoChange(key, val)
return val
end

local function matchesTitle(given, title)
local tp = type( given )
return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
end

local translate_mt = { __index = function(t, k) return k end }

function arguments.getArgs(frame, options)
checkType('getArgs', 1, frame, 'table', true)
checkType('getArgs', 2, options, 'table', true)
frame = frame or {}
options = options or {}

--[[
-- Set up argument translation.
--]]
options.translate = options.translate or {}
if getmetatable(options.translate) == nil then
setmetatable(options.translate, translate_mt)
end
if options.backtranslate == nil then
options.backtranslate = {}
for k,v in pairs(options.translate) do
options.backtranslate[v] = k
end
end
if options.backtranslate and getmetatable(options.backtranslate) == nil then
setmetatable(options.backtranslate, {
__index = function(t, k)
if options.translate[k] ~= k then
return nil
else
return k
end
end
})
end

--[[
-- Get the argument tables. If we were passed a valid frame object, get the
-- frame arguments (fargs) and the parent frame arguments (pargs), depending
-- on the options set and on the parent frame's availability. If we weren't
-- passed a valid frame object, we are being called from another Lua module
-- or from the debug console, so assume that we were passed a table of args
-- directly, and assign it to a new variable (luaArgs).
--]]
local fargs, pargs, luaArgs
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
if options.wrappers then
--[[
-- The wrappers option makes Module:Arguments look up arguments in
-- either the frame argument table or the parent argument table, but
-- not both. This means that users can use either the #invoke syntax
-- or a wrapper template without the loss of performance associated
-- with looking arguments up in both the frame and the parent frame.
-- Module:Arguments will look up arguments in the parent frame
-- if it finds the parent frame's title in options.wrapper;
-- otherwise it will look up arguments in the frame object passed
-- to getArgs.
--]]
local parent = frame:getParent()
if not parent then
fargs = frame.args
else
local title = parent:getTitle():gsub('/sandbox$', '')
local found = false
if matchesTitle(options.wrappers, title) then
found = true
elseif type(options.wrappers) == 'table' then
for _,v in pairs(options.wrappers) do
if matchesTitle(v, title) then
found = true
break
end
end
end

-- We test for false specifically here so that nil (the default) acts like true.
if found or options.frameOnly == false then
pargs = parent.args
end
if not found or options.parentOnly == false then
fargs = frame.args
end
end
else
-- options.wrapper isn't set, so check the other options.
if not options.parentOnly then
fargs = frame.args
end
if not options.frameOnly then
local parent = frame:getParent()
pargs = parent and parent.args or nil
end
end
if options.parentFirst then
fargs, pargs = pargs, fargs
end
else
luaArgs = frame
end

-- Set the order of precedence of the argument tables. If the variables are
-- nil, nothing will be added to the table, which is how we avoid clashes
-- between the frame/parent args and the Lua args.
local argTables = {fargs}
argTables[#argTables + 1] = pargs
argTables[#argTables + 1] = luaArgs

--[[
-- Generate the tidyVal function. If it has been specified by the user, we
-- use that; if not, we choose one of four functions depending on the
-- options chosen. This is so that we don't have to call the options table
-- every time the function is called.
--]]
local tidyVal = options.valueFunc
if tidyVal then
if type(tidyVal) ~= 'function' then
error(
"bad value assigned to option 'valueFunc'"
.. '(function expected, got '
.. type(tidyVal)
.. ')',
2
)
end
elseif options.trim ~= false then
if options.removeBlanks ~= false then
tidyVal = tidyValDefault
else
tidyVal = tidyValTrimOnly
end
else
if options.removeBlanks ~= false then
tidyVal = tidyValRemoveBlanksOnly
else
tidyVal = tidyValNoChange
end
end

--[[
-- Set up the args, metaArgs and nilArgs tables. args will be the one
-- accessed from functions, and metaArgs will hold the actual arguments. Nil
-- arguments are memoized in nilArgs, and the metatable connects all of them
-- together.
--]]
local args, metaArgs, nilArgs, metatable = {}, {}, {}, {}
setmetatable(args, metatable)

local function mergeArgs(tables)
--[[
-- Accepts multiple tables as input and merges their keys and values
-- into one table. If a value is already present it is not overwritten;
-- tables listed earlier have precedence. We are also memoizing nil
-- values, which can be overwritten if they are 's' (soft).
--]]
for _, t in ipairs(tables) do
for key, val in pairs(t) do
if metaArgs[key] == nil and nilArgs[key] ~= 'h' then
local tidiedVal = tidyVal(key, val)
if tidiedVal == nil then
nilArgs[key] = 's'
else
metaArgs[key] = tidiedVal
end
end
end
end
end

--[[
-- Define metatable behaviour. Arguments are memoized in the metaArgs table,
-- and are only fetched from the argument tables once. Fetching arguments
-- from the argument tables is the most resource-intensive step in this
-- module, so we try and avoid it where possible. For this reason, nil
-- arguments are also memoized, in the nilArgs table. Also, we keep a record
-- in the metatable of when pairs and ipairs have been called, so we do not
-- run pairs and ipairs on the argument tables more than once. We also do
-- not run ipairs on fargs and pargs if pairs has already been run, as all
-- the arguments will already have been copied over.
--]]

metatable.__index = function (t, key)
--[[
-- Fetches an argument when the args table is indexed. First we check
-- to see if the value is memoized, and if not we try and fetch it from
-- the argument tables. When we check memoization, we need to check
-- metaArgs before nilArgs, as both can be non-nil at the same time.
-- If the argument is not present in metaArgs, we also check whether
-- pairs has been run yet. If pairs has already been run, we return nil.
-- This is because all the arguments will have already been copied into
-- metaArgs by the mergeArgs function, meaning that any other arguments
-- must be nil.
--]]
if type(key) == 'string' then
key = options.translate[key]
end
local val = metaArgs[key]
if val ~= nil then
return val
elseif metatable.donePairs or nilArgs[key] then
return nil
end
for _, argTable in ipairs(argTables) do
local argTableVal = tidyVal(key, argTable[key])
if argTableVal ~= nil then
metaArgs[key] = argTableVal
return argTableVal
end
end
nilArgs[key] = 'h'
return nil
end

metatable.__newindex = function (t, key, val)
-- This function is called when a module tries to add a new value to the
-- args table, or tries to change an existing value.
if type(key) == 'string' then
key = options.translate[key]
end
if options.readOnly then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; the table is read-only',
2
)
elseif options.noOverwrite and args[key] ~= nil then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; overwriting existing arguments is not permitted',
2
)
elseif val == nil then
--[[
-- If the argument is to be overwritten with nil, we need to erase
-- the value in metaArgs, so that __index, __pairs and __ipairs do
-- not use a previous existing value, if present; and we also need
-- to memoize the nil in nilArgs, so that the value isn't looked
-- up in the argument tables if it is accessed again.
--]]
metaArgs[key] = nil
nilArgs[key] = 'h'
else
metaArgs[key] = val
end
end

local function translatenext(invariant)
local k, v = next(invariant.t, invariant.k)
invariant.k = k
if k == nil then
return nil
elseif type(k) ~= 'string' or not options.backtranslate then
return k, v
else
local backtranslate = options.backtranslate[k]
if backtranslate == nil then
-- Skip this one. This is a tail call, so this won't cause stack overflow
return translatenext(invariant)
else
return backtranslate, v
end
end
end

metatable.__pairs = function ()
-- Called when pairs is run on the args table.
if not metatable.donePairs then
mergeArgs(argTables)
metatable.donePairs = true
end
return translatenext, { t = metaArgs }
end

local function inext(t, i)
-- This uses our __index metamethod
local v = t[i + 1]
if v ~= nil then
return i + 1, v
end
end

metatable.__ipairs = function (t)
-- Called when ipairs is run on the args table.
return inext, t, 0
end

return args
end

return arguments

Module:Main

2020-12-16T22:32:53Z

Aurum86:

--[[
-- This module produces a link to a main article or articles. It implements the
-- template {{main}}.
--
-- If the module is used in category or category talk space, it produces "The
-- main article for this category is xxx." Otherwise, it produces
-- "Main article: xxx".
--]]

local mHatnote = require('Module:Hatnote')
local mHatlist = require('Module:Hatnote list')
local mArguments -- lazily initialise
local p = {}

function p.main(frame)
mArguments = require('Module:Arguments')
local args = mArguments.getArgs(frame, {parentOnly = true})
local pages = {}
for k, v in pairs(args) do
if type(k) == 'number' then
local display = args['label ' .. k] or args['l' .. k]
local page = display and
string.format('%s|%s', string.gsub(v, '|.*$', ''), display) or v
pages[#pages + 1] = page
end
end
if #pages == 0 and mw.title.getCurrentTitle().namespace == 0 then
return mHatnote.makeWikitextError(
'no page names specified',
'Template:Main#Errors',
args.category
)
end
local options = {
selfref = args.selfref
}
return p._main(pages, options)
end

function p._main(args, options)
-- Get the list of pages. If no first page was specified we use the current
-- page name.
local currentTitle = mw.title.getCurrentTitle()
if #args == 0 then args = {currentTitle.text} end
local firstPage = string.gsub(args[1], '|.*$', '')
-- Find the pagetype.
local pageType = mHatnote.findNamespaceId(firstPage) == 0 and 'article' or 'page'
-- Make the formatted link text
list = mHatlist.andList(args, true)
-- Build the text.
local isPlural = #args > 1
local mainForm
local curNs = currentTitle.namespace
if (curNs == 14) or (curNs == 15) then --category/talk namespaces
mainForm = isPlural and
'The main %ss for this [[Help:Categories|category]] are %s.'
or
'The main %s for this [[Help:Categories|category]] is %s.'
else
mainForm = isPlural and 'Main %ss: %s' or 'Main %s: %s'
end
local text = string.format(mainForm, pageType, list)
-- Process the options and pass the text to the _rellink function in
-- [[Module:Hatnote]].
options = options or {}
local hnOptions = {
selfref = options.selfref
}
return mHatnote._hatnote(text, hnOptions)
end

return p

Module:Main

2020-12-16T22:32:19Z

Aurum86:

--[[
-- This module produces a link to a main article or articles. It implements the
-- template {{main}}.
--
-- If the module is used in category or category talk space, it produces "The
-- main article for this category is xxx." Otherwise, it produces
-- "Main article: xxx".
--]]

local mHatnote = require('Module:Hatnote')
local mHatlist = require('Module:Hatnote_list')
local mArguments -- lazily initialise
local p = {}

function p.main(frame)
mArguments = require('Module:Arguments')
local args = mArguments.getArgs(frame, {parentOnly = true})
local pages = {}
for k, v in pairs(args) do
if type(k) == 'number' then
local display = args['label ' .. k] or args['l' .. k]
local page = display and
string.format('%s|%s', string.gsub(v, '|.*$', ''), display) or v
pages[#pages + 1] = page
end
end
if #pages == 0 and mw.title.getCurrentTitle().namespace == 0 then
return mHatnote.makeWikitextError(
'no page names specified',
'Template:Main#Errors',
args.category
)
end
local options = {
selfref = args.selfref
}
return p._main(pages, options)
end

function p._main(args, options)
-- Get the list of pages. If no first page was specified we use the current
-- page name.
local currentTitle = mw.title.getCurrentTitle()
if #args == 0 then args = {currentTitle.text} end
local firstPage = string.gsub(args[1], '|.*$', '')
-- Find the pagetype.
local pageType = mHatnote.findNamespaceId(firstPage) == 0 and 'article' or 'page'
-- Make the formatted link text
list = mHatlist.andList(args, true)
-- Build the text.
local isPlural = #args > 1
local mainForm
local curNs = currentTitle.namespace
if (curNs == 14) or (curNs == 15) then --category/talk namespaces
mainForm = isPlural and
'The main %ss for this [[Help:Categories|category]] are %s.'
or
'The main %s for this [[Help:Categories|category]] is %s.'
else
mainForm = isPlural and 'Main %ss: %s' or 'Main %s: %s'
end
local text = string.format(mainForm, pageType, list)
-- Process the options and pass the text to the _rellink function in
-- [[Module:Hatnote]].
options = options or {}
local hnOptions = {
selfref = options.selfref
}
return mHatnote._hatnote(text, hnOptions)
end

return p

Module:Hatnote list

2020-12-16T22:29:30Z

Aurum86: Naujas puslapis: -------------------------------------------------------------------------------- -- Module:Hatnote list -- --...

--------------------------------------------------------------------------------
-- Module:Hatnote list --
-- --
-- This module produces and formats lists for use in hatnotes. In particular, --
-- it implements the for-see list, i.e. lists of "For X, see Y" statements, --
-- as used in {{about}}, {{redirect}}, and their variants. Also introduced --
-- are andList & orList helpers for formatting lists with those conjunctions. --
--------------------------------------------------------------------------------

local mArguments --initialize lazily
local mHatnote = require('Module:Hatnote')
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local p = {}

--------------------------------------------------------------------------------
-- List stringification helper functions
--
-- These functions are used for stringifying lists, usually page lists inside
-- the "Y" portion of "For X, see Y" for-see items.
--------------------------------------------------------------------------------

--default options table used across the list stringification functions
local stringifyListDefaultOptions = {
conjunction = "and",
separator = ",",
altSeparator = ";",
space = " ",
formatted = false
}

-- Stringifies a list generically; probably shouldn't be used directly
function stringifyList(list, options)
-- Type-checks, defaults, and a shortcut
checkType("stringifyList", 1, list, "table")
if #list == 0 then return nil end
checkType("stringifyList", 2, options, "table", true)
options = options or {}
for k, v in pairs(stringifyListDefaultOptions) do
if options[k] == nil then options[k] = v end
end
local s = options.space
-- Format the list if requested
if options.formatted then list = mHatnote.formatPages(unpack(list)) end
-- Set the separator; if any item contains it, use the alternate separator
local separator = options.separator
--searches display text only
local function searchDisp(t, f)
return string.find(string.sub(t, (string.find(t, '|') or 0) + 1), f)
end
for k, v in pairs(list) do
if searchDisp(v, separator) then
separator = options.altSeparator
break
end
end
-- Set the conjunction, apply Oxford comma, and force a comma if #1 has "§"
local conjunction = s .. options.conjunction .. s
if #list == 2 and searchDisp(list[1], "§") or #list > 2 then
conjunction = separator .. conjunction
end
-- Return the formatted string
return mw.text.listToText(list, separator .. s, conjunction)
end

--DRY function
function conjList (conj, list, fmt)
return stringifyList(list, {conjunction = conj, formatted = fmt})
end

-- Stringifies lists with "and" or "or"
function p.andList (...) return conjList("and", ...) end
function p.orList (...) return conjList("or", ...) end

--------------------------------------------------------------------------------
-- For see
--
-- Makes a "For X, see [[Y]]." list from raw parameters. Intended for the
-- {{about}} and {{redirect}} templates and their variants.
--------------------------------------------------------------------------------

--default options table used across the forSee family of functions
local forSeeDefaultOptions = {
andKeyword = 'and',
title = mw.title.getCurrentTitle().text,
otherText = 'other uses',
forSeeForm = 'For %s, see %s.',
}

--Collapses duplicate punctuation
function punctuationCollapse (text)
local replacements = {
["%.%.$"] = ".",
["%?%.$"] = "?",
["%!%.$"] = "!",
["%.%]%]%.$"] = ".]]",
["%?%]%]%.$"] = "?]]",
["%!%]%]%.$"] = "!]]"
}
for k, v in pairs(replacements) do text = string.gsub(text, k, v) end
return text
end

-- Structures arguments into a table for stringification, & options
function p.forSeeArgsToTable (args, from, options)
-- Type-checks and defaults
checkType("forSeeArgsToTable", 1, args, 'table')
checkType("forSeeArgsToTable", 2, from, 'number', true)
from = from or 1
checkType("forSeeArgsToTable", 3, options, 'table', true)
options = options or {}
for k, v in pairs(forSeeDefaultOptions) do
if options[k] == nil then options[k] = v end
end
-- maxArg's gotten manually because getArgs() and table.maxn aren't friends
local maxArg = 0
for k, v in pairs(args) do
if type(k) == 'number' and k > maxArg then maxArg = k end
end
-- Structure the data out from the parameter list:
-- * forTable is the wrapper table, with forRow rows
-- * Rows are tables of a "use" string & a "pages" table of pagename strings
-- * Blanks are left empty for defaulting elsewhere, but can terminate list
local forTable = {}
local i = from
local terminated = false
-- If there is extra text, and no arguments are given, give nil value
-- to not produce default of "For other uses, see foo (disambiguation)"
if options.extratext and i > maxArg then return nil end
-- Loop to generate rows
repeat
-- New empty row
local forRow = {}
-- On blank use, assume list's ended & break at end of this loop
forRow.use = args[i]
if not args[i] then terminated = true end
-- New empty list of pages
forRow.pages = {}
-- Insert first pages item if present
table.insert(forRow.pages, args[i + 1])
-- If the param after next is "and", do inner loop to collect params
-- until the "and"'s stop. Blanks are ignored: "1|and||and|3" → {1, 3}
while args[i + 2] == options.andKeyword do
if args[i + 3] then
table.insert(forRow.pages, args[i + 3])
end
-- Increment to next "and"
i = i + 2
end
-- Increment to next use
i = i + 2
-- Append the row
table.insert(forTable, forRow)
until terminated or i > maxArg

return forTable
end

-- Stringifies a table as formatted by forSeeArgsToTable
function p.forSeeTableToString (forSeeTable, options)
-- Type-checks and defaults
checkType("forSeeTableToString", 1, forSeeTable, "table", true)
checkType("forSeeTableToString", 2, options, "table", true)
options = options or {}
for k, v in pairs(forSeeDefaultOptions) do
if options[k] == nil then options[k] = v end
end
-- Stringify each for-see item into a list
local strList = {}
if forSeeTable then
for k, v in pairs(forSeeTable) do
local useStr = v.use or options.otherText
local pagesStr = p.andList(v.pages, true) or mHatnote._formatLink{link = mHatnote.disambiguate(options.title)}
local forSeeStr = string.format(options.forSeeForm, useStr, pagesStr)
forSeeStr = punctuationCollapse(forSeeStr)
table.insert(strList, forSeeStr)
end
end
if options.extratext then table.insert(strList, punctuationCollapse(options.extratext..'.')) end
-- Return the concatenated list
return table.concat(strList, ' ')
end

-- Produces a "For X, see [[Y]]" string from arguments. Expects index gaps
-- but not blank/whitespace values. Ignores named args and args < "from".
function p._forSee (args, from, options)
local forSeeTable = p.forSeeArgsToTable(args, from, options)
return p.forSeeTableToString(forSeeTable, options)
end

-- As _forSee, but uses the frame.
function p.forSee (frame, from, options)
mArguments = require('Module:Arguments')
return p._forSee(mArguments.getArgs(frame), from, options)
end

return p

Module:Hatnote

2020-12-16T22:21:03Z

Aurum86: Naujas puslapis: -------------------------------------------------------------------------------- -- Module:Hatnote -- --...

--------------------------------------------------------------------------------
-- Module:Hatnote --
-- --
-- This module produces hatnote links and links to related articles. It --
-- implements the {{hatnote}} and {{format link}} meta-templates and includes --
-- helper functions for other Lua hatnote modules. --
--------------------------------------------------------------------------------

local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local checkTypeForNamedArg = libraryUtil.checkTypeForNamedArg
local mArguments -- lazily initialise [[Module:Arguments]]
local yesno -- lazily initialise [[Module:Yesno]]

local p = {}

--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------

local function getArgs(frame)
-- Fetches the arguments from the parent frame. Whitespace is trimmed and
-- blanks are removed.
mArguments = require('Module:Arguments')
return mArguments.getArgs(frame, {parentOnly = true})
end

local function removeInitialColon(s)
-- Removes the initial colon from a string, if present.
return s:match('^:?(.*)')
end

function p.findNamespaceId(link, removeColon)
-- Finds the namespace id (namespace number) of a link or a pagename. This
-- function will not work if the link is enclosed in double brackets. Colons
-- are trimmed from the start of the link by default. To skip colon
-- trimming, set the removeColon parameter to false.
checkType('findNamespaceId', 1, link, 'string')
checkType('findNamespaceId', 2, removeColon, 'boolean', true)
if removeColon ~= false then
link = removeInitialColon(link)
end
local namespace = link:match('^(.-):')
if namespace then
local nsTable = mw.site.namespaces[namespace]
if nsTable then
return nsTable.id
end
end
return 0
end

function p.formatPages(...)
-- Formats a list of pages using formatLink and returns it as an array. Nil
-- values are not allowed.
local pages = {...}
local ret = {}
for i, page in ipairs(pages) do
ret[i] = p._formatLink{link = page}
end
return ret
end

function p.formatPageTables(...)
-- Takes a list of page/display tables and returns it as a list of
-- formatted links. Nil values are not allowed.
local pages = {...}
local links = {}
for i, t in ipairs(pages) do
checkType('formatPageTables', i, t, 'table')
local link = t[1]
local display = t[2]
links[i] = p._formatLink{link = link, display = display}
end
return links
end

function p.makeWikitextError(msg, helpLink, addTrackingCategory, title)
-- Formats an error message to be returned to wikitext. If
-- addTrackingCategory is not false after being returned from
-- [[Module:Yesno]], and if we are not on a talk page, a tracking category
-- is added.
checkType('makeWikitextError', 1, msg, 'string')
checkType('makeWikitextError', 2, helpLink, 'string', true)
yesno = require('Module:Yesno')
title = title or mw.title.getCurrentTitle()
-- Make the help link text.
local helpText
if helpLink then
helpText = ' ([[' .. helpLink .. '|help]])'
else
helpText = ''
end
-- Make the category text.
local category
if not title.isTalkPage -- Don't categorise talk pages
and title.namespace ~= 2 -- Don't categorise userspace
and yesno(addTrackingCategory) ~= false -- Allow opting out
then
category = 'Hatnote templates with errors'
category = string.format(
'[[%s:%s]]',
mw.site.namespaces[14].name,
category
)
else
category = ''
end
return string.format(
'<strong class="error">Error: %s%s.</strong>%s',
msg,
helpText,
category
)
end

function p.disambiguate(page, disambiguator)
-- Formats a page title with a disambiguation parenthetical,
-- i.e. "Example" → "Example (disambiguation)".
checkType('disambiguate', 1, page, 'string')
checkType('disambiguate', 2, disambiguator, 'string', true)
disambiguator = disambiguator or 'disambiguation'
return string.format('%s (%s)', page, disambiguator)
end

--------------------------------------------------------------------------------
-- Format link
--
-- Makes a wikilink from the given link and display values. Links are escaped
-- with colons if necessary, and links to sections are detected and displayed
-- with " § " as a separator rather than the standard MediaWiki "#". Used in
-- the {{format link}} template.
--------------------------------------------------------------------------------

function p.formatLink(frame)
-- The formatLink export function, for use in templates.
yesno = require('Module:Yesno')
local args = getArgs(frame)
local link = args[1]
if not link then
return p.makeWikitextError(
'no link specified',
'Template:Format link#Errors',
args.category
)
end
return p._formatLink{
link = link,
display = args[2],
italicizePage = yesno(args.italicizepage),
italicizeSection = yesno(args.italicizesection),
}
end

local function italicize(s)
-- Italicize a string.
return '<i>' .. s .. '</i>'
end

local function maybeItalicize(s, shouldItalicize)
-- italicize s if s is a string and the shouldItalicize parameter is true.
if s and shouldItalicize then
return italicize(s)
else
return s
end
end

local function parseLink(link)
-- Parse a link and return a table with the link's components.
-- These components are:
-- - link: the link, stripped of any initial colon (always present)
-- - page: the page name (always present)
-- - section: the page name (may be nil)
-- - display: the display text, if manually entered after a pipe (may be nil)
link = removeInitialColon(link)

-- Find whether a faux display value has been added with the {{!}} magic
-- word.
local prePipe, display = link:match('^(.-)|(.*)$')
link = prePipe or link

-- Find the page, if it exists.
-- For links like [[#Bar]], the page will be nil.
local preHash, postHash = link:match('^(.-)#(.*)$')
local page
if not preHash then
-- We have a link like [[Foo]].
page = link
elseif preHash ~= '' then
-- We have a link like [[Foo#Bar]].
page = preHash
end

-- Find the section, if it exists.
local section
if postHash and postHash ~= '' then
section = postHash
end

return {
link = link,
page = page,
section = section,
display = display,
}
end

function p._formatLink(options)
-- The formatLink export function, for use in modules.
checkType('_formatLink', 1, options, 'table')
checkTypeForNamedArg('_formatLink', 'link', options.link, 'string', false)
checkTypeForNamedArg(
'_formatLink',
'display',
options.display,
'string',
true
)
checkTypeForNamedArg(
'_formatLink',
'italicizePage',
options.italicizePage,
'boolean',
true
)
checkTypeForNamedArg(
'_formatLink',
'italicizeSection',
options.italicizeSection,
'boolean',
true
)

local parsed = parseLink(options.link)
local display = options.display or parsed.display

-- Deal with the case where we don't have to pipe the link
if not display and not parsed.section and not options.italicizePage then
return string.format('[[:%s]]', parsed.link)
end

-- Find the display text for piped links
if not display then
local page = maybeItalicize(parsed.page, options.italicizePage)
local section = maybeItalicize(parsed.section, options.italicizeSection)
if not page then
display = string.format('§ %s', section)
elseif section then
display = string.format('%s § %s', page, section)
else
display = page
end
end

return string.format('[[:%s|%s]]', parsed.link, display)
end

--------------------------------------------------------------------------------
-- Hatnote
--
-- Produces standard hatnote text. Implements the {{hatnote}} template.
--------------------------------------------------------------------------------

function p.hatnote(frame)
local args = getArgs(frame)
local s = args[1]
local options = {}
if not s then
return p.makeWikitextError(
'no text specified',
'Template:Hatnote#Errors',
args.category
)
end
options.extraclasses = args.extraclasses
options.selfref = args.selfref
return p._hatnote(s, options)
end

function p._hatnote(s, options)
checkType('_hatnote', 1, s, 'string')
checkType('_hatnote', 2, options, 'table', true)
options = options or {}
local classes = {'hatnote', 'navigation-not-searchable'}
local extraclasses = options.extraclasses
local selfref = options.selfref
if type(extraclasses) == 'string' then
classes[#classes + 1] = extraclasses
end
if selfref then
classes[#classes + 1] = 'selfref'
end
return string.format(
'<div role="note" class="%s">%s</div>',
table.concat(classes, ' '),
s
)
end

return p

Module:Main

2020-12-16T22:20:06Z

Aurum86: Naujas puslapis: --[[ -- This module produces a link to a main article or articles. It implements the -- template {{main}}. -- -- If the module is used in category or category talk space, it pro...

--[[
-- This module produces a link to a main article or articles. It implements the
-- template {{main}}.
--
-- If the module is used in category or category talk space, it produces "The
-- main article for this category is xxx." Otherwise, it produces
-- "Main article: xxx".
--]]

local mHatnote = require('Module:Hatnote')
local mHatlist = require('Module:Hatnote list')
local mArguments -- lazily initialise
local p = {}

function p.main(frame)
mArguments = require('Module:Arguments')
local args = mArguments.getArgs(frame, {parentOnly = true})
local pages = {}
for k, v in pairs(args) do
if type(k) == 'number' then
local display = args['label ' .. k] or args['l' .. k]
local page = display and
string.format('%s|%s', string.gsub(v, '|.*$', ''), display) or v
pages[#pages + 1] = page
end
end
if #pages == 0 and mw.title.getCurrentTitle().namespace == 0 then
return mHatnote.makeWikitextError(
'no page names specified',
'Template:Main#Errors',
args.category
)
end
local options = {
selfref = args.selfref
}
return p._main(pages, options)
end

function p._main(args, options)
-- Get the list of pages. If no first page was specified we use the current
-- page name.
local currentTitle = mw.title.getCurrentTitle()
if #args == 0 then args = {currentTitle.text} end
local firstPage = string.gsub(args[1], '|.*$', '')
-- Find the pagetype.
local pageType = mHatnote.findNamespaceId(firstPage) == 0 and 'article' or 'page'
-- Make the formatted link text
list = mHatlist.andList(args, true)
-- Build the text.
local isPlural = #args > 1
local mainForm
local curNs = currentTitle.namespace
if (curNs == 14) or (curNs == 15) then --category/talk namespaces
mainForm = isPlural and
'The main %ss for this [[Help:Categories|category]] are %s.'
or
'The main %s for this [[Help:Categories|category]] is %s.'
else
mainForm = isPlural and 'Main %ss: %s' or 'Main %s: %s'
end
local text = string.format(mainForm, pageType, list)
-- Process the options and pass the text to the _rellink function in
-- [[Module:Hatnote]].
options = options or {}
local hnOptions = {
selfref = options.selfref
}
return mHatnote._hatnote(text, hnOptions)
end

return p

Šablonas:Main

2020-12-16T22:11:30Z

Aurum86:

{{#invoke:main|main}}<noinclude>
{{documentation}}

</noinclude>

Šablonas:Main

2020-12-15T21:26:49Z

Aurum86: Naujas puslapis: test

test

Vaizdas:Logo angis black.png

2020-12-14T20:27:57Z

Aurum86: logo Angis black

== Aprašymas ==
logo Angis black