# 50 JavaScript statybos pamokų

Pamokos pateiktos sunkėjančia tvarka. Kiekvienos pamokos pavyzdys yra atskira programa ir naudoja šio žaidimo JavaScript komandas. Pirmiausia pabandyk atlikti užduotį pats, o tik tada nagrinėk sprendimą.

## Pasiruošimas

Žaidime pasirink JavaScript režimą. Pradėk netoli pradinės vietos (X = 0, Z = 0) ir palauk pasaulio įkėlimo. Statybos vieta: X ir Z nuo 0 iki 19, Y nuo 10 iki 31. Pagrindas bus Y = 9.

Prieš kiekvieną pamoką atskirai paleisk šį paruošimo kodą. Jis ištrina ankstesnius statinius ir medžius tik šioje aikštelėje. Programa naudoja 9600 veiksmų, todėl jos nejunk su pamokos programa.

```javascript
for (let x = 0; x < 20; x++) {
  for (let z = 0; z < 20; z++) {
    for (let y = 9; y < 32; y++) {
      removeBlock(x, y, z);
    }
    placeBlock(x, 9, z, 3);
  }
}
```

Vienam paleidimui leidžiama iki 10000 veiksmų ir 5 sekundžių skaičiavimo. Pakeitimai pritaikomi baigus skaičiavimą. placeBlock deda bloką tik tuščioje vietoje; norint pakeisti medžiagą pirmiausia reikia removeBlock.

Blokų tipai: 1 žolė, 2 žemė, 3 akmuo, 4 anglis, 5 geležis, 6 medis, 7 lapai, 8 smėlis, 9 debesis.

## Turinys

1. Pirmasis stulpelis
2. Spalvotas takelis
3. Maži vartai
4. Vienos medžiagos suoliukas
5. Augantis bokštelis
6. Perkeliama gėlių lysvė
7. Ilgas takas
8. Aukšta kolona
9. Laiptai
10. Aikštelė
11. Siena
12. Dryžuotas grindinys
13. Siena su durimis
14. Kiemo tvora
15. Siena su langu
16. Masyvus postamentas
17. Dvi vienodos kolonos
18. Skirtingų bokštų alėja
19. Skaičiuojamos plytelės
20. Laiptuota piramidė
21. Spalvų mozaika
22. Bokštai pagal planą
23. Namelis pagal nustatymus
24. Bokštas iki žymeklio
25. Tiltas iki atramos
26. Kolonada su praėjimais
27. Namas su dvišlaičiu stogu
28. Apvalus bokštas
29. Mažas kaimelis
30. Baigiamasis projektas: pilis
31. Tvirtovė su vidiniu kiemu
32. Arkinis tiltas
33. Dantyta arena
34. Dryžuotas švyturys
35. Šventykla su kolonada
36. Piramidė su kamera
37. Kabantis tiltas
38. Laikrodžio bokštas
39. Katedros fasadas
40. Algoritminis labirintas
41. Amfiteatras
42. Penkių aukštų pagoda
43. Burlaivis
44. Vėjo malūnas
45. Observatorija su kupolu
46. Laiptuotas monumentas
47. Geležinkelio stotis
48. Tvirtovės miestas
49. Procedūrinis dangoraižis
50. Baigiamasis projektas: išmanus miestas

## 1. Pirmasis stulpelis

**Sąvokos:** placeBlock

**Tikslas:** Pastatyti trijų akmens blokų stulpelį.

**Užduotis:** Padėk tris blokus vieną virš kito ties X = 2 ir Z = 2. Pradėk nuo Y = 10.

**Patarimas:** X ir Z lieka tokie patys. Kiekvieno kito bloko Y padidėja vienetu.

### Sprendimo pavyzdys

```javascript
placeBlock(2, 10, 2, 3);
placeBlock(2, 11, 2, 3);
placeBlock(2, 12, 2, 3);
```

**Pasitikrink:** Vienas 3 blokų aukščio stulpelis, be tarpų.

**Papildomas iššūkis:** Padaryk jį 5 blokų aukščio.


## 2. Spalvotas takelis

**Sąvokos:** placeBlock, komentarai

**Tikslas:** Pastatyti keturių skirtingų medžiagų takelį.

**Užduotis:** Vienoje eilėje padėk žolės, žemės, akmens ir smėlio blokus. Prie kodo pažymėk medžiagas komentarais.

**Patarimas:** Paskutinis placeBlock argumentas parenka medžiagą; // pradeda komentarą.

### Sprendimo pavyzdys

```javascript
placeBlock(2, 10, 2, 1); // Zole
placeBlock(3, 10, 2, 2); // Zeme
placeBlock(4, 10, 2, 3); // Akmuo
placeBlock(5, 10, 2, 8); // Smelis
```

**Pasitikrink:** 4 blokai vienoje horizontalioje eilėje, visi skirtingi.

**Papildomas iššūkis:** Pratęsk takelį medžio ir lapų blokais.


## 3. Maži vartai

**Sąvokos:** placeBlock, koordinates

**Tikslas:** Pastatyti vartus su tuščia anga.

**Užduotis:** Pastatyk dvi 2 blokų aukščio atramas ir 3 blokų pločio skersinį virš jų.

**Patarimas:** Atramos ties X = 2 ir X = 4; vidurinė vieta X = 3 apačioje turi likti tuščia.

### Sprendimo pavyzdys

```javascript
placeBlock(2, 10, 2, 3);
placeBlock(2, 11, 2, 3);
placeBlock(4, 10, 2, 3);
placeBlock(4, 11, 2, 3);
placeBlock(2, 12, 2, 3);
placeBlock(3, 12, 2, 3);
placeBlock(4, 12, 2, 3);
```

**Pasitikrink:** 7 blokai sudaro apverstos U raidės vartus.

**Papildomas iššūkis:** Padidink angą iki 2 blokų pločio.


## 4. Vienos medžiagos suoliukas

**Sąvokos:** const

**Tikslas:** Panaudoti konstantą suoliuko medžiagai pasirinkti.

**Užduotis:** Sukurk konstantą medis, tada pastatyk dvi kojas ir 3 blokų ilgio sėdynę.

**Patarimas:** const saugo reikšmę, kurios šiame kode neperrašysi. Medžio ID yra 6.

### Sprendimo pavyzdys

```javascript
const medis = 6;
placeBlock(2, 10, 2, medis);
placeBlock(4, 10, 2, medis);
placeBlock(2, 11, 2, medis);
placeBlock(3, 11, 2, medis);
placeBlock(4, 11, 2, medis);
```

**Pasitikrink:** 5 medžio blokų suoliukas.

**Papildomas iššūkis:** Pakeisk vieną konstantos reikšmę ir pastatyk akmeninį suoliuką.


## 5. Augantis bokštelis

**Sąvokos:** let, operatoriai

**Tikslas:** Keisti aukštį naudojant kintamąjį.

**Užduotis:** Sukurk let y = 10. Padėjęs bloką, padidink y ir statyk kitą.

**Patarimas:** y = y + 1 perskaičiuoja kintamojo reikšmę.

### Sprendimo pavyzdys

```javascript
let y = 10;
placeBlock(2, y, 2, 3);
y = y + 1;
placeBlock(2, y, 2, 3);
y = y + 1;
placeBlock(2, y, 2, 3);
y = y + 1;
placeBlock(2, y, 2, 5);
```

**Pasitikrink:** 4 blokų bokštelis su geležies bloku viršuje.

**Papildomas iššūkis:** Naudok y += 1 vietoje y = y + 1.


## 6. Perkeliama gėlių lysvė

**Sąvokos:** const, operatoriai

**Tikslas:** Viso objekto vietą aprašyti pradžios koordinatėmis.

**Užduotis:** Pastatyk 2 × 2 žolės lysvę. Visas koordinates apskaičiuok pagal x ir z konstantas.

**Patarimas:** x + 1 reiškia vietą vienu bloku toliau nuo pasirinktos pradžios.

### Sprendimo pavyzdys

```javascript
const x = 3;
const z = 3;
placeBlock(x, 10, z, 1);
placeBlock(x + 1, 10, z, 1);
placeBlock(x, 10, z + 1, 1);
placeBlock(x + 1, 10, z + 1, 1);
```

**Pasitikrink:** Keturi blokai sudaro kvadratą.

**Papildomas iššūkis:** Perkelk visą lysvę pakeisdamas tik x ir z.


## 7. Ilgas takas

**Sąvokos:** for, let, operatoriai

**Tikslas:** Pakartoti vieną komandą ciklu.

**Užduotis:** Naudodamas for pastatyk 8 blokų ilgio akmeninį taką.

**Patarimas:** x prasideda nuo 2; x < 10 neįtraukia 10.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x < 10; x++) {
  placeBlock(x, 10, 2, 3);
}
```

**Pasitikrink:** Tiksliai 8 blokai nuo X = 2 iki X = 9.

**Papildomas iššūkis:** Padaryk 12 blokų taką.


## 8. Aukšta kolona

**Sąvokos:** for, const

**Tikslas:** Atskirti statinio dydį nuo ciklo pradžios.

**Užduotis:** Pastatyk 6 blokų koloną. Jos aukštį laikyk konstantoje.

**Patarimas:** Skaitiklis i yra poslinkis, todėl tikrasis Y yra 10 + i.

### Sprendimo pavyzdys

```javascript
const aukstis = 6;
for (let i = 0; i < aukstis; i++) {
  placeBlock(3, 10 + i, 3, 6);
}
```

**Pasitikrink:** Kolona nuo Y = 10 iki Y = 15.

**Papildomas iššūkis:** Viršuje pridėk lapų bloką ties 10 + aukstis.


## 9. Laiptai

**Sąvokos:** for, operatoriai

**Tikslas:** Vienu skaitikliu keisti ir vietą, ir aukštį.

**Užduotis:** Pastatyk 6 pakopas. Kiekviena pakopa juda per vieną bloką į šoną ir aukštyn.

**Patarimas:** Tas pats i naudojamas X ir Y koordinatėse.

### Sprendimo pavyzdys

```javascript
for (let i = 0; i < 6; i++) {
  placeBlock(2 + i, 10 + i, 3, 3);
}
```

**Pasitikrink:** 6 įstrižai kylantys laiptų blokai.

**Papildomas iššūkis:** Greta pridėk tokią pačią eilę, kad laiptai būtų platesni.


## 10. Aikštelė

**Sąvokos:** for

**Tikslas:** Suprasti įdėtinius ciklus: eilutės ir stulpeliai.

**Užduotis:** Pastatyk 6 × 5 medinę aikštelę.

**Patarimas:** Kiekvienai X reikšmei vidinis ciklas pereina visas Z reikšmes.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x < 8; x++) {
  for (let z = 2; z < 7; z++) {
    placeBlock(x, 10, z, 6);
  }
}
```

**Pasitikrink:** 30 blokų viename horizontaliame sluoksnyje.

**Papildomas iššūkis:** Naudok plotis ir ilgis konstantas.


## 11. Siena

**Sąvokos:** for

**Tikslas:** Pritaikyti du ciklus vertikaliai plokštumai.

**Užduotis:** Pastatyk 7 blokų pločio ir 4 blokų aukščio sieną.

**Patarimas:** Keičiasi X ir Y; Z yra pastovus.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x < 9; x++) {
  for (let y = 10; y < 14; y++) {
    placeBlock(x, y, 3, 3);
  }
}
```

**Pasitikrink:** 28 blokų siena.

**Papildomas iššūkis:** Pasuk sieną: keisk Z, o X laikyk pastovų.


## 12. Dryžuotas grindinys

**Sąvokos:** if, else, operatoriai

**Tikslas:** Parinkti medžiagą pagal sąlygą.

**Užduotis:** Pastatyk 8 × 4 grindinį. Lyginių X juostas padaryk akmenines, nelyginių - smėlio.

**Patarimas:** x % 2 yra dalybos iš 2 liekana. === tikrina lygybę.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x < 10; x++) {
  for (let z = 2; z < 6; z++) {
    if (x % 2 === 0) {
      placeBlock(x, 10, z, 3);
    } else {
      placeBlock(x, 10, z, 8);
    }
  }
}
```

**Pasitikrink:** 8 juostos, medžiaga keičiasi kas vieną X.

**Papildomas iššūkis:** Naudok (x + z) % 2 ir sukurk šachmatų raštą.


## 13. Siena su durimis

**Sąvokos:** if, else, operatoriai

**Tikslas:** Sujungti dvi sąlygas naudojant &&.

**Užduotis:** Pastatyk 7 × 4 sieną su 1 × 2 durų anga centre.

**Patarimas:** Anga yra ten, kur x === 5 IR y < 12.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x < 9; x++) {
  for (let y = 10; y < 14; y++) {
    if (x === 5 && y < 12) {
      // Durys lieka tuscios.
    } else {
      placeBlock(x, y, 3, 3);
    }
  }
}
```

**Pasitikrink:** 26 blokai; anga yra 2 blokų aukščio.

**Papildomas iššūkis:** Padaryk duris 2 blokų pločio.


## 14. Kiemo tvora

**Sąvokos:** if, operatoriai

**Tikslas:** Atrinkti kvadrato kraštus naudojant ||.

**Užduotis:** Pastatyk tuščiavidurį 7 × 7 medinį aptvarą viename sluoksnyje.

**Patarimas:** Blokas priklauso kraštui, jeigu bent viena koordinatė yra mažiausia arba didžiausia.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x <= 8; x++) {
  for (let z = 2; z <= 8; z++) {
    if (x === 2 || x === 8 || z === 2 || z === 8) {
      placeBlock(x, 10, z, 6);
    }
  }
}
```

**Pasitikrink:** 24 blokų rėmas, viduje tuščia.

**Papildomas iššūkis:** Palik vieno bloko vartelius vienoje kraštinėje.


## 15. Siena su langu

**Sąvokos:** removeBlock, for

**Tikslas:** Išpjauti angą jau pastatytame objekte.

**Užduotis:** Pastatyk 7 × 5 sieną, tada pašalink 2 × 2 lango blokus.

**Patarimas:** removeBlock vykdomas po sienos statymo ciklų.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x < 9; x++) {
  for (let y = 10; y < 15; y++) {
    placeBlock(x, y, 3, 3);
  }
}
for (let x = 4; x < 6; x++) {
  for (let y = 12; y < 14; y++) {
    removeBlock(x, y, 3);
  }
}
```

**Pasitikrink:** Lieka 31 sienos blokas, langas nesiekia žemės.

**Papildomas iššūkis:** Įrenk antrą mažą langą.


## 16. Masyvus postamentas

**Sąvokos:** for

**Tikslas:** Trijų ciklų pagalba užpildyti tūrį.

**Užduotis:** Pastatyk 4 × 3 × 4 akmeninį postamentą.

**Patarimas:** Išorinis ir vidinis ciklai valdo plotį bei gylį, trečiasis - aukštį.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x < 6; x++) {
  for (let y = 10; y < 13; y++) {
    for (let z = 2; z < 6; z++) {
      placeBlock(x, y, z, 3);
    }
  }
}
```

**Pasitikrink:** 48 blokų užpildytas stačiakampis gretasienis.

**Papildomas iššūkis:** Viršutinį sluoksnį padaryk iš geležies.


## 17. Dvi vienodos kolonos

**Sąvokos:** function

**Tikslas:** Iškelti pasikartojantį statymą į funkciją.

**Užduotis:** Aprašyk funkciją kolona(x, z), tada iškviesk ją dviejose vietose.

**Patarimas:** Parametrai leidžia tą patį veiksmą atlikti skirtingose koordinatėse.

### Sprendimo pavyzdys

```javascript
function kolona(x, z) {
  for (let y = 10; y < 15; y++) {
    placeBlock(x, y, z, 3);
  }
}
kolona(2, 3);
kolona(7, 3);
```

**Pasitikrink:** Dvi 5 blokų aukščio kolonos.

**Papildomas iššūkis:** Pastatyk dar dvi kolonas už pirmųjų.


## 18. Skirtingų bokštų alėja

**Sąvokos:** function, for

**Tikslas:** Funkcijos parametrais valdyti vietą, aukštį ir medžiagą.

**Užduotis:** Sukurk bokstas(x, aukstis, tipas) ir pastatyk tris skirtingus bokštelius.

**Patarimas:** Parametrų reikšmės nurodomos kiekvieno iškvietimo metu.

### Sprendimo pavyzdys

```javascript
function bokstas(x, aukstis, tipas) {
  for (let i = 0; i < aukstis; i++) {
    placeBlock(x, 10 + i, 3, tipas);
  }
}
bokstas(2, 3, 6);
bokstas(5, 5, 3);
bokstas(8, 7, 5);
```

**Pasitikrink:** Bokštai yra 3, 5 ir 7 blokų aukščio.

**Papildomas iššūkis:** Ciklu sukurk 5 bokštus su didėjančiu aukščiu.


## 19. Skaičiuojamos plytelės

**Sąvokos:** return, function, console.log

**Tikslas:** Grąžinti rezultatą iš funkcijos.

**Užduotis:** Sukurk funkciją, kuri pastato grindis ir grąžina jų blokų skaičių.

**Patarimas:** return užbaigia funkciją ir perduoda reikšmę jos kvietėjui.

### Sprendimo pavyzdys

```javascript
function grindys(plotis, ilgis) {
  for (let x = 0; x < plotis; x++) {
    for (let z = 0; z < ilgis; z++) {
      placeBlock(2 + x, 10, 2 + z, 6);
    }
  }
  return plotis * ilgis;
}
const kiekis = grindys(6, 4);
console.log(kiekis);
```

**Pasitikrink:** 6 × 4 grindys; išvestyje skaičius 24.

**Papildomas iššūkis:** Apskaičiuok ir išvesk dviejų skirtingų aikštelių bendrą blokų skaičių.


## 20. Laiptuota piramidė

**Sąvokos:** for, operatoriai

**Tikslas:** Kiekvienam sluoksniui mažinti ciklo ribas.

**Užduotis:** Pastatyk 4 sluoksnių piramidę: 7 × 7, 5 × 5, 3 × 3 ir 1 × 1.

**Patarimas:** Didėjant sluoksniui k, pradžia didėja, o pabaiga mažėja.

### Sprendimo pavyzdys

```javascript
for (let k = 0; k < 4; k++) {
  for (let x = 2 + k; x <= 8 - k; x++) {
    for (let z = 2 + k; z <= 8 - k; z++) {
      placeBlock(x, 10 + k, z, 8);
    }
  }
}
```

**Pasitikrink:** 84 smėlio blokai; viršūnė ties (5, 13, 5).

**Papildomas iššūkis:** Pritaikyk programą 5 sluoksnių piramidei.


## 21. Spalvų mozaika

**Sąvokos:** masyvai, for

**Tikslas:** Pasirinkti medžiagas iš masyvo.

**Užduotis:** Naudok 4 medžiagų masyvą ir kartok jo raštą 8 × 4 grindinyje.

**Patarimas:** Masyvo indeksai prasideda nuo 0. % tipai.length leidžia juos kartoti.

### Sprendimo pavyzdys

```javascript
const tipai = [1, 3, 6, 8];
for (let x = 0; x < 8; x++) {
  for (let z = 0; z < 4; z++) {
    const tipas = tipai[(x + z) % tipai.length];
    placeBlock(2 + x, 10, 2 + z, tipas);
  }
}
```

**Pasitikrink:** 32 blokų mozaika iš 4 medžiagų.

**Papildomas iššūkis:** Pridėk penktą medžiagą tik pakeisdamas masyvą.


## 22. Bokštai pagal planą

**Sąvokos:** masyvai, for...of, function

**Tikslas:** Pereiti sąrašą naudojant for...of.

**Užduotis:** Kiekvienam aukščių masyvo elementui pastatyk atskirą bokštą.

**Patarimas:** for...of duoda elemento reikšmę; X poziciją valdyk atskirai.

### Sprendimo pavyzdys

```javascript
function bokstas(x, aukstis) {
  for (let i = 0; i < aukstis; i++) {
    placeBlock(x, 10 + i, 3, 3);
  }
}
const auksciai = [3, 6, 4, 7, 5];
let x = 2;
for (const aukstis of auksciai) {
  bokstas(x, aukstis);
  x += 3;
}
```

**Pasitikrink:** 5 bokštai, išdėstyti kas 3 blokus.

**Papildomas iššūkis:** Pakeisk masyvą taip, kad bokštai sudarytų simetrišką siluetą.


## 23. Namelis pagal nustatymus

**Sąvokos:** objektai, for, if

**Tikslas:** Statinio nustatymus sujungti į objektą.

**Užduotis:** Objekte namas saugok vietą ir dydį. Pastatyk sienas, plokščią stogą ir durų angą.

**Patarimas:** namas.plotis skaito savybę. Kraštų sąlyga palieka tuščią vidų.

### Sprendimo pavyzdys

```javascript
const namas = { x: 2, z: 2, plotis: 7, ilgis: 6, aukstis: 4 };
for (let x = 0; x < namas.plotis; x++) {
  for (let z = 0; z < namas.ilgis; z++) {
    for (let h = 0; h <= namas.aukstis; h++) {
      const krastas = x === 0 || z === 0 || x === namas.plotis - 1 || z === namas.ilgis - 1;
      const stogas = h === namas.aukstis;
      const durys = x === 3 && z === 0 && h < 2;
      if ((krastas || stogas) && !durys) {
        placeBlock(namas.x + x, 10 + h, namas.z + z, 6);
      }
    }
  }
}
```

**Pasitikrink:** Tuščiaviduris namas su stogu ir 2 blokų aukščio durimis.

**Papildomas iššūkis:** Nustatymuose pridėk sienų medžiagą ir langą.


## 24. Bokštas iki žymeklio

**Sąvokos:** while, hasBlock

**Tikslas:** Kartoti statymą, kol sutinkama kliūtis.

**Užduotis:** Padėk geležies žymeklį ties Y = 16. Po juo augink medinę koloną, kol pasieksi žymeklį.

**Patarimas:** while sąlyga tikrinama prieš kiekvieną kartojimą. y++ būtinas, kad ciklas baigtųsi.

### Sprendimo pavyzdys

```javascript
placeBlock(3, 16, 3, 5);
let y = 10;
while (y < 20 && !hasBlock(3, y, 3)) {
  placeBlock(3, y, 3, 6);
  y++;
}
console.log(y);
```

**Pasitikrink:** 6 medžio blokai ir geležies viršūnė; išvestis 16.

**Papildomas iššūkis:** Perkelk žymeklį dviem blokais aukščiau.


## 25. Tiltas iki atramos

**Sąvokos:** break, hasBlock, if

**Tikslas:** Nutraukti ciklą aptikus norimą vietą.

**Užduotis:** Pastatyk atramą ties X = 9 ir tiesk tiltą nuo X = 2 iki jos.

**Patarimas:** break išeina tik iš artimiausio ciklo.

### Sprendimo pavyzdys

```javascript
for (let y = 10; y <= 12; y++) {
  placeBlock(9, y, 3, 3);
}
for (let x = 2; x < 16; x++) {
  if (hasBlock(x, 12, 3)) {
    break;
  }
  placeBlock(x, 12, 3, 6);
}
```

**Pasitikrink:** 7 mediniai tilto blokai pasiekia akmeninę atramą.

**Papildomas iššūkis:** Pridėk antrą lygiagrečią tilto eilę ir atramą.


## 26. Kolonada su praėjimais

**Sąvokos:** continue, for, operatoriai

**Tikslas:** Praleisti pasirinktus ciklo kartojimus.

**Užduotis:** Pastatyk kolonas kas 3 blokus ir virš jų vientisą siją.

**Patarimas:** continue praleidžia likusias dabartinio kartojimo komandas.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x <= 14; x++) {
  placeBlock(x, 14, 3, 3);
  if ((x - 2) % 3 !== 0) {
    continue;
  }
  for (let y = 10; y < 14; y++) {
    placeBlock(x, y, 3, 6);
  }
}
```

**Pasitikrink:** 5 kolonos ir jas jungianti 13 blokų sija.

**Papildomas iššūkis:** Kolonas išdėstyk kas 4 blokus.


## 27. Namas su dvišlaičiu stogu

**Sąvokos:** Math.abs, function, return

**Tikslas:** Aukštį apskaičiuoti pagal atstumą nuo centro.

**Užduotis:** Pastatyk 7 × 7 sienų kontūrą ir simetrišką stogą, aukščiausią per vidurį.

**Patarimas:** Math.abs(x - 5) yra atstumas nuo stogo vidurio X = 5.

### Sprendimo pavyzdys

```javascript
function stogoY(x) {
  return 16 - Math.abs(x - 5);
}
for (let x = 2; x <= 8; x++) {
  for (let z = 2; z <= 8; z++) {
    if (x === 2 || x === 8 || z === 2 || z === 8) {
      for (let y = 10; y < stogoY(x); y++) {
        if (!(x === 5 && z === 2 && y < 12)) {
          placeBlock(x, y, z, 6);
        }
      }
    }
    placeBlock(x, stogoY(x), z, 3);
  }
}
```

**Pasitikrink:** Stogo kraštai ties Y = 13, kraigas ties Y = 16.

**Papildomas iššūkis:** Įrenk po langą šoninėse sienose.


## 28. Apvalus bokštas

**Sąvokos:** Math.abs, if, operatoriai

**Tikslas:** Atrinkti blokus pagal atstumą nuo centro.

**Užduotis:** Pastatyk 6 sluoksnių tuščiavidurį bokštą iš žiedo formos sluoksnių.

**Patarimas:** dx * dx + dz * dz yra atstumo kvadratas. Nereikia skaičiuoti kvadratinės šaknies.

### Sprendimo pavyzdys

```javascript
const centras = 8;
const spindulys = 4;
for (let x = 4; x <= 12; x++) {
  for (let z = 4; z <= 12; z++) {
    const dx = x - centras;
    const dz = z - centras;
    const d2 = dx * dx + dz * dz;
    if (d2 <= spindulys * spindulys && d2 >= 9) {
      for (let y = 10; y < 16; y++) {
        placeBlock(x, y, z, 3);
      }
    }
  }
}
```

**Pasitikrink:** Bokšto vidus tuščias, sienos sudaro apvalų žiedą.

**Papildomas iššūkis:** Išpjauk duris ir viršuje pridėk dantytą parapetą.


## 29. Mažas kaimelis

**Sąvokos:** objektai, masyvai, for...of, function

**Tikslas:** Sujungti statymo funkciją su objektų sąrašu.

**Užduotis:** Sukurk trijų namų planus ir viena funkcija pastatyk visą kaimelį.

**Patarimas:** Kiekvienas plano objektas turi savo x, z ir tipas savybes.

### Sprendimo pavyzdys

```javascript
function namelis(planas) {
  for (let x = 0; x < 5; x++) {
    for (let z = 0; z < 5; z++) {
      for (let h = 0; h < 4; h++) {
        const siena = x === 0 || x === 4 || z === 0 || z === 4;
        const durys = x === 2 && z === 0 && h < 2;
        if ((siena || h === 3) && !durys) {
          placeBlock(planas.x + x, 10 + h, planas.z + z, planas.tipas);
        }
      }
    }
  }
}
const planai = [
  { x: 1, z: 2, tipas: 6 },
  { x: 8, z: 2, tipas: 3 },
  { x: 8, z: 10, tipas: 8 }
];
for (const planas of planai) {
  namelis(planas);
}
```

**Pasitikrink:** Trys atskiri namai su durimis ir stogais.

**Papildomas iššūkis:** Sujunk namų duris takais, neviršydamas 20 × 20 aikštelės.


## 30. Baigiamasis projektas: pilis

**Sąvokos:** function, objektai, masyvai, for...of, return, if

**Tikslas:** Savarankiškai suplanuoti objektą iš kelių pakartotinai naudojamų dalių.

**Užduotis:** Pastatyk keturis kampinius bokštus, juos jungiančias sienas, vartus ir taką kieme. Pirma nusipiešk planą ir suskaidyk jį į funkcijas.

**Patarimas:** Vienoda bokšto funkcija kviečiama keturis kartus. Sienoms užtenka patikrinti pilies perimetro koordinates.

### Sprendimo pavyzdys

```javascript
function bokstas(x0, z0) {
  for (let x = 0; x < 4; x++) {
    for (let z = 0; z < 4; z++) {
      for (let h = 0; h < 7; h++) {
        const krastas = x === 0 || x === 3 || z === 0 || z === 3;
        const dantis = (x + z) % 2 === 0;
        if (krastas && (h < 6 || dantis)) {
          placeBlock(x0 + x, 10 + h, z0 + z, 3);
        }
      }
    }
  }
}
function vartai(x, z, y) {
  return z === 2 && x >= 8 && x <= 10 && y < 13;
}
const kampai = [
  { x: 2, z: 2 }, { x: 13, z: 2 },
  { x: 2, z: 13 }, { x: 13, z: 13 }
];
for (const kampas of kampai) {
  bokstas(kampas.x, kampas.z);
}
for (let x = 2; x <= 16; x++) {
  for (let z = 2; z <= 16; z++) {
    if (x === 2 || x === 16 || z === 2 || z === 16) {
      for (let y = 10; y < 14; y++) {
        if (!vartai(x, z, y)) {
          placeBlock(x, y, z, 3);
        }
      }
    }
  }
}
for (let z = 3; z < 13; z++) {
  placeBlock(9, 10, z, 8);
}
console.log("Pilis pastatyta!");
```

**Pasitikrink:** 4 aukštesni bokštai, uždaras sienų perimetras su 3 × 3 vartų anga ir takas kieme.

**Papildomas iššūkis:** Pridėk centrinį pastatą, langus ir vėliavą. Sukurk nustatymų objektą, kad medžiagas būtų galima keisti vienoje vietoje.


## 31. Tvirtovė su vidiniu kiemu

**Sąvokos:** function, for, if

**Tikslas:** Po pilies projekto sukurti parametrizuotą tvirtovės perimetrą.

**Užduotis:** Pastatyk 16 × 16 sienų perimetrą, keturis kampinius bokštus ir 3 × 3 vartus.

**Patarimas:** Atskirk bokšto ir sienos statymą į funkcijas. Vartų vietą praleisk sąlyga.

### Sprendimo pavyzdys

```javascript
function bokstas(x0, z0) {
  for (let x = 0; x < 3; x++) for (let z = 0; z < 3; z++) {
    for (let y = 10; y <= 17; y++) {
      if (x === 0 || x === 2 || z === 0 || z === 2) placeBlock(x0 + x, y, z0 + z, 3);
    }
  }
}
for (let x = 2; x <= 17; x++) for (let z = 2; z <= 17; z++) {
  if (x === 2 || x === 17 || z === 2 || z === 17) {
    for (let y = 10; y <= 14; y++) {
      const vartai = z === 2 && x >= 8 && x <= 10 && y <= 12;
      if (!vartai) placeBlock(x, y, z, 3);
    }
  }
}
for (const p of [[2,2],[15,2],[2,15],[15,15]]) bokstas(p[0], p[1]);
```

**Pasitikrink:** Uždaras perimetras, keturi aukšti bokštai ir atvira vartų anga.

**Papildomas iššūkis:** Pridėk dantis ant sienų ir bokštų.


## 32. Arkinis tiltas

**Sąvokos:** Math.abs, function, for

**Tikslas:** Apskaičiuoti arkos formą pagal atstumą nuo centro.

**Užduotis:** Pastatyk 16 blokų ilgio, 3 blokų pločio tiltą su atramomis, paliekančiomis arką.

**Patarimas:** Atramos apačią kelk artėjant prie centro: Math.abs(x - centras).

### Sprendimo pavyzdys

```javascript
const centras = 9.5;
for (let x = 2; x <= 17; x++) {
  const tarpas = 10 + Math.max(0, 4 - Math.abs(x - centras));
  for (let z = 7; z <= 9; z++) {
    placeBlock(x, 16, z, 3);
    for (let y = 10; y < tarpas; y++) placeBlock(x, y, z, 3);
  }
}
```

**Pasitikrink:** Viršuje vientisas kelias, apačioje simetriška arkinė anga.

**Papildomas iššūkis:** Pridėk medinius turėklus abiejuose tilto kraštuose.


## 33. Dantyta arena

**Sąvokos:** operatoriai, for, if

**Tikslas:** Pastatyti ovalią areną iš kelių koncentrinių kontūrų.

**Užduotis:** Naudok atstumo formulę ovalo sienoms ir laiptuotoms žiūrovų eilėms.

**Patarimas:** Normalizuok dx ir dz skirtingais dalikliais; atrink reikšmes tarp dviejų ribų.

### Sprendimo pavyzdys

```javascript
for (let x = 1; x <= 18; x++) for (let z = 3; z <= 16; z++) {
  const dx = (x - 9.5) / 8.5;
  const dz = (z - 9.5) / 6.5;
  const d = dx * dx + dz * dz;
  if (d >= 0.72 && d <= 1.08) {
    for (let y = 10; y <= 14; y++) placeBlock(x, y, z, 3);
    if ((x + z) % 2 === 0) placeBlock(x, 15, z, 5);
  } else if (d >= 0.38 && d < 0.72) {
    placeBlock(x, 10, z, 8);
    placeBlock(x, 11, z, 8);
  }
}
```

**Pasitikrink:** Arena turi išorinę sieną, dantis ir vidines sėdimų vietų eiles.

**Papildomas iššūkis:** Viename gale palik 3 blokų pločio įėjimą.


## 34. Dryžuotas švyturys

**Sąvokos:** function, operatoriai, for

**Tikslas:** Sujungti cilindrinį bokštą su periodišku spalvų raštu.

**Užduotis:** Pastatyk tuščiavidurį švyturį, kurio medžiaga keičiasi kas du aukščio sluoksnius.

**Patarimas:** Math.floor((y - 10) / 2) % 2 parenka dviejų sluoksnių juostas.

### Sprendimo pavyzdys

```javascript
for (let y = 10; y <= 22; y++) {
  const tipas = Math.floor((y - 10) / 2) % 2 === 0 ? 3 : 8;
  for (let x = 5; x <= 11; x++) for (let z = 5; z <= 11; z++) {
    const d2 = (x - 8) ** 2 + (z - 8) ** 2;
    if (d2 >= 8 && d2 <= 13) placeBlock(x, y, z, tipas);
  }
}
for (let x = 6; x <= 10; x++) for (let z = 6; z <= 10; z++) placeBlock(x, 23, z, 5);
```

**Pasitikrink:** 13 sluoksnių dryžuotas bokštas su geležine viršūne.

**Papildomas iššūkis:** Viršūnėje įrengti debesies blokų šviesą.


## 35. Šventykla su kolonada

**Sąvokos:** function, for...of, masyvai

**Tikslas:** Statinį sudėti iš grindų, kolonų, sijų ir laiptuoto stogo.

**Užduotis:** Pastatyk 14 × 10 pagrindą ir simetrišką kolonų tinklą.

**Patarimas:** Kolonų X ir Z vietas laikyk masyvuose.

### Sprendimo pavyzdys

```javascript
function kolona(x, z) {
  for (let y = 11; y <= 16; y++) placeBlock(x, y, z, 3);
}
for (let x = 3; x <= 16; x++) for (let z = 5; z <= 14; z++) placeBlock(x, 10, z, 8);
for (const x of [3,6,9,12,15]) for (const z of [5,14]) kolona(x, z);
for (let x = 2; x <= 17; x++) for (let z = 4; z <= 15; z++) placeBlock(x, 17, z, 3);
for (let x = 4; x <= 15; x++) for (let z = 6; z <= 13; z++) placeBlock(x, 18, z, 3);
```

**Pasitikrink:** Pakelta aikštelė, 10 kolonų ir dviejų pakopų stogas.

**Papildomas iššūkis:** Pridėk centrinį altorių ir priekinius laiptus.


## 36. Piramidė su kamera

**Sąvokos:** for, if, operatoriai

**Tikslas:** Sluoksniuoto statinio viduje palikti tiksliai apibrėžtą tuštumą.

**Užduotis:** Pastatyk 9 sluoksnių piramidę, bet centre palik 3 × 3 × 4 kamerą ir koridorių.

**Patarimas:** Prieš dėdamas bloką patikrink, ar koordinatė nepriklauso kamerai arba koridoriui.

### Sprendimo pavyzdys

```javascript
for (let k = 0; k < 9; k++) {
  for (let x = 1 + k; x <= 18 - k; x++) for (let z = 1 + k; z <= 18 - k; z++) {
    const y = 10 + k;
    const kamera = x >= 9 && x <= 11 && z >= 9 && z <= 11 && y <= 13;
    const koridorius = x === 10 && z <= 9 && y <= 11;
    if (!kamera && !koridorius) placeBlock(x, y, z, 8);
  }
}
```

**Pasitikrink:** Piramidė turi paslėptą centrinę kamerą ir koridorių iš priekinės pusės.

**Papildomas iššūkis:** Kameroje pastatyk geležies postamentą.


## 37. Kabantis tiltas

**Sąvokos:** Math.abs, function, for

**Tikslas:** Apskaičiuoti lenktus lynus ir pakabas.

**Užduotis:** Pastatyk du bokštus, denį, du lenktus lynus ir vertikalias pakabas.

**Patarimas:** Lyno aukštis gali būti 17 + Math.floor(Math.abs(x - 10) / 2).

### Sprendimo pavyzdys

```javascript
for (const x of [2,17]) for (let y = 10; y <= 22; y++) for (const z of [7,10]) placeBlock(x, y, z, 3);
for (let x = 2; x <= 17; x++) {
  for (let z = 8; z <= 9; z++) placeBlock(x, 15, z, 6);
  const lynasY = 17 + Math.floor(Math.abs(x - 9.5) / 2);
  for (const z of [7,10]) {
    placeBlock(x, lynasY, z, 5);
    if (x % 2 === 0) for (let y = 16; y < lynasY; y++) placeBlock(x, y, z, 5);
  }
}
```

**Pasitikrink:** Tiltas turi du bokštus, denį, žemėjantį lyną ir pakabas.

**Papildomas iššūkis:** Pridėk atramas po deniu abiejuose krantuose.


## 38. Laikrodžio bokštas

**Sąvokos:** function, for, if

**Tikslas:** Sukomponuoti bokštą, laikrodžio ciferblatus ir smailę.

**Užduotis:** Pastatyk 7 × 7 bokštą, keturis ciferblatus ir laiptuotą stogą.

**Patarimas:** Ciferblatas yra 3 × 3 plotas kiekvienos sienos centre; jo rodykles žymėk geležimi.

### Sprendimo pavyzdys

```javascript
for (let x = 6; x <= 12; x++) for (let z = 6; z <= 12; z++) {
  if (x === 6 || x === 12 || z === 6 || z === 12) for (let y = 10; y <= 20; y++) placeBlock(x, y, z, 3);
}
for (let a = 7; a <= 11; a++) for (let y = 16; y <= 19; y++) {
  const tipas = (a === 9 || y === 18) ? 5 : 8;
  placeBlock(a, y, 6, tipas); placeBlock(a, y, 12, tipas);
  placeBlock(6, y, a, tipas); placeBlock(12, y, a, tipas);
}
for (let k = 0; k < 4; k++) for (let x = 6 + k; x <= 12 - k; x++) for (let z = 6 + k; z <= 12 - k; z++) placeBlock(x, 21 + k, z, 6);
```

**Pasitikrink:** Aukštas bokštas su keturiais matomais ciferblatais ir smaile.

**Papildomas iššūkis:** Pakeisk rodyklių kryptį viename ciferblate.


## 39. Katedros fasadas

**Sąvokos:** Math.abs, function, if

**Tikslas:** Sukurti simetrišką fasadą su portalu, langu ir dviem bokštais.

**Užduotis:** Pastatyk priekinę sieną, smailėjančią centrinę dalį ir tuščias angas.

**Patarimas:** Fasado viršutinę ribą apskaičiuok pagal atstumą nuo centro.

### Sprendimo pavyzdys

```javascript
for (let x = 2; x <= 17; x++) {
  const virsus = 17 + Math.max(0, 5 - Math.abs(x - 9.5));
  for (let y = 10; y <= virsus; y++) {
    const durys = x >= 8 && x <= 10 && y <= 14;
    const langas = x >= 8 && x <= 11 && y >= 16 && y <= 19;
    if (!durys && !langas) placeBlock(x, y, 5, 3);
  }
}
for (const x of [2,15]) for (let dx = 0; dx < 3; dx++) for (let y = 10; y <= 23; y++) placeBlock(x + dx, y, 5, 3);
```

**Pasitikrink:** Simetriškas fasadas, portalas, aukštas langas ir du šoniniai bokštai.

**Papildomas iššūkis:** Pridėk spalvotą lango raštą ir laiptus.


## 40. Algoritminis labirintas

**Sąvokos:** operatoriai, for, if

**Tikslas:** Pagal koordinačių taisyklę sugeneruoti pravažiuojamą labirinto raštą.

**Užduotis:** Pastatyk išorines sienas ir vidines juostas su kintančiais tarpais.

**Patarimas:** Kas antrame X statyk sieną, o angos Z vietą apskaičiuok iš X.

### Sprendimo pavyzdys

```javascript
for (let x = 1; x <= 18; x++) for (let z = 1; z <= 18; z++) {
  const krastas = x === 1 || x === 18 || z === 1 || z === 18;
  const juosta = x % 2 === 0 && z !== 2 + (x * 3) % 15;
  if (krastas || juosta) {
    placeBlock(x, 10, z, 6);
    placeBlock(x, 11, z, 6);
  }
}
```

**Pasitikrink:** Labirintas turi išorinę ribą ir skirtingose vietose praviras vidines sienas.

**Papildomas iššūkis:** Pridėk horizontalias sienas neblokuodamas visų praėjimų.


## 41. Amfiteatras

**Sąvokos:** Math.abs, for, if

**Tikslas:** Pastatyti pusapskritimes, aukštėjančias žiūrovų eiles.

**Užduotis:** Atrink penkis pusžiedžius ir kiekvieną tolimesnį kelk aukščiau.

**Patarimas:** Skaičiuok d2 nuo scenos centro ir tikrink siaurą intervalo juostą.

### Sprendimo pavyzdys

```javascript
for (let r = 4; r <= 8; r++) {
  for (let x = 1; x <= 18; x++) for (let z = 6; z <= 18; z++) {
    const d2 = (x - 10) ** 2 + (z - 6) ** 2;
    if (d2 >= r * r - r && d2 <= r * r + r) placeBlock(x, 9 + r - 3, z, 8);
  }
}
for (let x = 5; x <= 15; x++) for (let z = 2; z <= 5; z++) placeBlock(x, 10, z, 6);
```

**Pasitikrink:** Penkios aukštėjančios pusapskritimės eilės žiūri į medinę sceną.

**Papildomas iššūkis:** Pridėk du scenos bokštelius ir foninę sieną.


## 42. Penkių aukštų pagoda

**Sąvokos:** function, for, operatoriai

**Tikslas:** Kartoti aukštus, kurių plotis palaipsniui mažėja.

**Užduotis:** Pastatyk penkis aukštus su sienomis ir platesniais stogų karnizais.

**Patarimas:** Kiekvieno aukšto pradžia didėja, o dydis mažėja.

### Sprendimo pavyzdys

```javascript
for (let aukstas = 0; aukstas < 5; aukstas++) {
  const pradzia = 2 + aukstas;
  const pabaiga = 17 - aukstas;
  const y0 = 10 + aukstas * 3;
  for (let x = pradzia + 1; x < pabaiga; x++) for (let z = pradzia + 1; z < pabaiga; z++) {
    if (x === pradzia + 1 || x === pabaiga - 1 || z === pradzia + 1 || z === pabaiga - 1) placeBlock(x, y0, z, 6);
  }
  for (let x = pradzia; x <= pabaiga; x++) for (let z = pradzia; z <= pabaiga; z++) placeBlock(x, y0 + 1, z, 3);
}
```

**Pasitikrink:** Penki mažėjantys aukštai su aiškiai išsikišusiais stogais.

**Papildomas iššūkis:** Ant viršaus pridėk 4 blokų smailę.


## 43. Burlaivis

**Sąvokos:** Math.abs, function, for

**Tikslas:** Sudėti lenktą korpusą, denį, stiebus ir bures.

**Užduotis:** Korpuso plotį keisk pagal atstumą nuo laivo vidurio.

**Patarimas:** Korpuso pusplotį apskaičiuok iš Math.floor((8 - Math.abs(x - 10)) / 2).

### Sprendimo pavyzdys

```javascript
for (let x = 2; x <= 18; x++) {
  const puse = Math.max(1, Math.floor((9 - Math.abs(x - 10)) / 2));
  for (let z = 10 - puse; z <= 10 + puse; z++) {
    placeBlock(x, 10, z, 6);
    if (z === 10 - puse || z === 10 + puse) placeBlock(x, 11, z, 6);
  }
}
for (const x of [7,13]) {
  for (let y = 11; y <= 21; y++) placeBlock(x, y, 10, 6);
  for (let y = 15; y <= 20; y++) for (let z = 11; z <= 14; z++) placeBlock(x, y, z, 8);
}
```

**Pasitikrink:** Smailėjantis korpusas, du stiebai ir dvi stačiakampės burės.

**Papildomas iššūkis:** Padaryk bures trikampes ir pridėk laivagalio kajutę.


## 44. Vėjo malūnas

**Sąvokos:** function, Math.abs, for

**Tikslas:** Sujungti bokštą, stogą ir keturias simetriškas mentes.

**Užduotis:** Pastatyk siaurėjantį bokštą ir X bei Y kryptimis besitęsiančias mentes.

**Patarimas:** Mentės centrą laikyk viename taške, o atstumą keisk nuo -5 iki 5.

### Sprendimo pavyzdys

```javascript
for (let y = 10; y <= 18; y++) {
  const r = y < 15 ? 3 : 2;
  for (let x = 10 - r; x <= 10 + r; x++) for (let z = 8 - r; z <= 8 + r; z++) {
    if (x === 10 - r || x === 10 + r || z === 8 - r || z === 8 + r) placeBlock(x, y, z, 3);
  }
}
for (let d = -5; d <= 5; d++) {
  placeBlock(10 + d, 17, 5, 6);
  placeBlock(10, 17 + d, 5, 6);
  if (Math.abs(d) >= 2) placeBlock(10 + d, 18, 5, 7);
}
```

**Pasitikrink:** Siaurėjantis bokštas ir keturios kryžminės mentės priekinėje pusėje.

**Papildomas iššūkis:** Mentėms pridėk antrą lapų blokų juostą.


## 45. Observatorija su kupolu

**Sąvokos:** operatoriai, Math.abs, if

**Tikslas:** Apskaičiuoti sferinio kupolo sluoksnių spindulį.

**Užduotis:** Pastatyk cilindrinę bazę ir pusapvalį kupolą su plyšiu teleskopui.

**Patarimas:** Kiekviename aukštyje leistinas horizontalus atstumas mažėja pagal r² - dy².

### Sprendimo pavyzdys

```javascript
for (let y = 10; y <= 14; y++) for (let x = 4; x <= 16; x++) for (let z = 4; z <= 16; z++) {
  const d2 = (x - 10) ** 2 + (z - 10) ** 2;
  if (d2 >= 30 && d2 <= 38) placeBlock(x, y, z, 3);
}
for (let y = 15; y <= 21; y++) {
  const dy = y - 15;
  const r2 = 36 - dy * dy;
  for (let x = 4; x <= 16; x++) for (let z = 4; z <= 16; z++) {
    const d2 = (x - 10) ** 2 + (z - 10) ** 2;
    const plysys = x === 10 && z <= 10;
    if (!plysys && d2 <= r2 && d2 >= r2 - 12) placeBlock(x, y, z, 5);
  }
}
```

**Pasitikrink:** Cilindrinė bazė ir siaurėjantis kupolas su centriniu plyšiu.

**Papildomas iššūkis:** Plyšyje pastatyk įstrižą teleskopą.


## 46. Laiptuotas monumentas

**Sąvokos:** function, for, operatoriai

**Tikslas:** Rekursinį vaizdą sukurti pasikartojančiais mažėjančiais rėmais.

**Užduotis:** Pastatyk šešis pakeltus kvadratinius rėmus ir centrinę koloną.

**Patarimas:** Kiekviename lygyje mažink pradžią bei pabaigą ir kelk Y.

### Sprendimo pavyzdys

```javascript
for (let k = 0; k < 6; k++) {
  const a = 2 + k;
  const b = 17 - k;
  const y = 10 + k * 2;
  for (let x = a; x <= b; x++) for (let z = a; z <= b; z++) {
    if (x === a || x === b || z === a || z === b) placeBlock(x, y, z, k % 2 === 0 ? 3 : 5);
  }
  for (let h = 10; h < y; h++) placeBlock(a, h, a, 6);
}
for (let y = 10; y <= 24; y++) placeBlock(10, y, 10, 5);
```

**Pasitikrink:** Šeši vis mažesni rėmai skirtinguose aukščiuose ir centrinė kolona.

**Papildomas iššūkis:** Sujunk visus keturis kiekvieno rėmo kampus atramomis.


## 47. Geležinkelio stotis

**Sąvokos:** function, masyvai, for...of

**Tikslas:** Pakartotiniais moduliais pastatyti peronus, bėgius ir arkinį stogą.

**Užduotis:** Sukurk dvi bėgių poras, du peronus ir stogo atramas kas 4 blokus.

**Patarimas:** Bėgių Z koordinates bei atramų X vietas laikyk masyvuose.

### Sprendimo pavyzdys

```javascript
for (const z of [5,6,13,14]) for (let x = 1; x <= 18; x++) placeBlock(x, 10, z, 5);
for (const z of [3,9,16]) for (let x = 1; x <= 18; x++) placeBlock(x, 10, z, 8);
for (const x of [2,6,10,14,18]) {
  for (const z of [3,16]) for (let y = 11; y <= 17; y++) placeBlock(x, y, z, 3);
  for (let z = 3; z <= 16; z++) {
    const y = 18 + Math.max(0, 4 - Math.abs(z - 9.5));
    placeBlock(x, y, z, 6);
  }
}
```

**Pasitikrink:** Dvi bėgių poros, trys platformos ir penki arkiniai stogo skersiniai.

**Papildomas iššūkis:** Sujunk skersinius išilginėmis stogo juostomis.


## 48. Tvirtovės miestas

**Sąvokos:** objektai, masyvai, function, for...of

**Tikslas:** Pagal duomenų planą pastatyti skirtingo dydžio miesto pastatus.

**Užduotis:** Sukurk penkių pastatų planą ir bendrą miesto sieną su vartais.

**Patarimas:** Kiekvienas objektas aprašo pradžią, dydį, aukštį ir medžiagą.

### Sprendimo pavyzdys

```javascript
function pastatas(p) {
  for (let x = 0; x < p.w; x++) for (let z = 0; z < p.d; z++) for (let h = 0; h <= p.h; h++) {
    const siena = x === 0 || z === 0 || x === p.w - 1 || z === p.d - 1;
    if (siena || h === p.h) placeBlock(p.x + x, 10 + h, p.z + z, p.t);
  }
}
const planas = [
  {x:3,z:3,w:4,d:4,h:4,t:6}, {x:9,z:3,w:5,d:4,h:6,t:3},
  {x:3,z:10,w:5,d:5,h:5,t:8}, {x:11,z:10,w:4,d:5,h:7,t:5}
];
for (const p of planas) pastatas(p);
for (let a = 1; a <= 18; a++) for (let y = 10; y <= 12; y++) {
  if (!(a >= 8 && a <= 10 && y < 12)) placeBlock(a, y, 1, 3);
}
```

**Pasitikrink:** Keturi skirtingi pastatai ir priekinė miesto siena su vartais.

**Papildomas iššūkis:** Aplink visą miestą užbaik sieną ir pridėk gatves.


## 49. Procedūrinis dangoraižis

**Sąvokos:** function, operatoriai, for

**Tikslas:** Aukštus generuoti moduliais, keičiant fasado raštą.

**Užduotis:** Pastatyk 14 aukštų bokštą su langais, perdangomis ir siaurėjančia viršūne.

**Patarimas:** Kas trečiame aukšte dėk pilną perdangą, kituose - tik sienas su langų raštu.

### Sprendimo pavyzdys

```javascript
for (let h = 0; h < 14; h++) {
  const inset = h >= 10 ? 1 : 0;
  for (let x = 5 + inset; x <= 14 - inset; x++) for (let z = 5 + inset; z <= 14 - inset; z++) {
    const krastas = x === 5 + inset || x === 14 - inset || z === 5 + inset || z === 14 - inset;
    const perdanga = h % 3 === 0;
    const langas = (x + z + h) % 3 === 0;
    if (perdanga || (krastas && !langas)) placeBlock(x, 10 + h, z, perdanga ? 3 : 5);
  }
}
for (let y = 24; y <= 27; y++) placeBlock(10, y, 10, 5);
```

**Pasitikrink:** 14 modulinių aukštų, langų raštas, siauresnė viršūnė ir antena.

**Papildomas iššūkis:** Pirmame aukšte palik įėjimą ir pridėk stogo platformą.


## 50. Baigiamasis projektas: išmanus miestas

**Sąvokos:** objektai, masyvai, function, for...of, if

**Tikslas:** Sujungti duomenų planą, funkcijas, geometrines taisykles ir kelių tipų infrastruktūrą.

**Užduotis:** Pastatyk keturis skirtingo aukščio pastatus, gatvių tinklą, centrinį parką, bokštą ir miesto vartus.

**Patarimas:** Pirma funkcijomis aprašyk pastatą ir kelią, tada vykdyk objektų planą.

### Sprendimo pavyzdys

```javascript
function pastatas(p) {
  for (let h = 0; h < p.h; h++) for (let x = 0; x < p.w; x++) for (let z = 0; z < p.d; z++) {
    const siena = x === 0 || z === 0 || x === p.w - 1 || z === p.d - 1;
    const langas = (x + z + h) % 3 === 0;
    if (h === p.h - 1 || (siena && !langas)) placeBlock(p.x + x, 10 + h, p.z + z, p.t);
  }
}
const pastatai = [
  {x:1,z:1,w:5,d:5,h:7,t:3}, {x:14,z:1,w:5,d:5,h:10,t:5},
  {x:1,z:14,w:5,d:5,h:5,t:6}, {x:14,z:14,w:5,d:5,h:8,t:8}
];
for (const p of pastatai) pastatas(p);
for (let a = 0; a < 20; a++) {
  for (let w = 8; w <= 11; w++) {
    placeBlock(a, 10, w, 3); placeBlock(w, 10, a, 3);
  }
}
for (let x = 7; x <= 12; x++) for (let z = 7; z <= 12; z++) {
  if (x < 9 || x > 10 || z < 9 || z > 10) placeBlock(x, 11, z, 1);
}
for (let y = 11; y <= 24; y++) placeBlock(10, y, 10, 5);
for (let x = 7; x <= 12; x++) placeBlock(x, 16, 9, 6);
```

**Pasitikrink:** Keturi skirtingi pastatai, kryžminės gatvės, žalias centras ir aukštas miesto orientyras.

**Papildomas iššūkis:** Sukurk savo penktą pastato tipą ir prijunk jį prie kelių tinklo.
