Od pierwszych projektów do coraz bardziej samodzielnego tworzenia
W wieku 9–12 lat dzieci są już gotowe nie tylko poznawać podstawy programowania, ale również tworzyć coraz bardziej rozbudowane projekty, eksperymentować z różnymi technologiami i szukać własnych sposobów rozwiązania problemu.
Na naszych zajęciach programowanie nie oznacza przepisywania kodu czy wykonywania kolejnych poleceń prowadzącego. Uczestnicy tworzą gry, aplikacje i interaktywne projekty, uczą się planować ich działanie, testować rozwiązania i poprawiać błędy.
Korzystamy z różnych środowisk – od programowania blokowego po pierwsze języki tekstowe – ponieważ nie zależy nam na nauczeniu jednego programu. Zależy nam na nauczeniu sposobu myślenia, który można wykorzystać w różnych technologiach.
Najpierw uczę się, jak coś zrobić. Potem zaczynam rozumieć, dlaczego działa. W końcu próbuję zrobić to po swojemu.
Co dziecko rozwija?
- logiczne i analityczne myślenie,
- rozwiązywanie problemów,
- planowanie większych projektów,
- samodzielność,
- kreatywność,
- debugowanie i analizowanie błędów,
- wytrwałość,
- świadome korzystanie z technologii.
Programowanie to nie tylko nauka kodu. To trening myślenia w sytuacji, w której nie zawsze istnieje jedna gotowa odpowiedź.
Jak wyglądają zajęcia?
1. Poznajemy wyzwanie
2. Planujemy rozwiązanie
3. Programujemy
4. Uruchamiamy i testujemy
5. Szukamy błędów i poprawiamy
6. Rozwijamy projekt o własne pomysły
A co, jeśli nie działa?
Zostawiamy, bo to jedna z fajniejszych cech całej naszej nowej komunikacji.
Tutaj możemy już użyć słowa debugowanie i od razu je wyjaśnić:
Debugowanie, czyli szukanie i poprawianie błędów, jest normalną częścią pracy każdego programisty.
Nie naprawiamy od razu programu za uczestnika. Pomagamy mu zastanowić się:
Co miało się wydarzyć? → Co wydarzyło się naprawdę? → Gdzie może być problem? → Co możemy zmienić?
Od gotowych przykładów do samodzielnych projektów
Na początku prowadzący pokazuje więcej przykładów. Później uczestnicy modyfikują projekty, łączą poznane wcześniej rozwiązania, a następnie realizują coraz bardziej samodzielne zadania.
Celem nie jest wykonanie dokładnie tego samego projektu przez całą grupę. Celem jest dojście do momentu, w którym dziecko potrafi wykorzystać poznane narzędzia do realizacji własnego pomysłu.
Oferta na rok szkolny 2026/27
Grupa wiekowa: 9-12 lat
Programowanie blokowe
(Scratch, App Inventor)
Kurs dla dzieci w wieku 9–12 lat, które chcą rozpocząć naukę programowania poprzez tworzenie własnych gier, animacji i aplikacji.
Zaczynamy od intuicyjnego programowania blokowego, dzięki któremu dziecko może skupić się na logice programu, zależnościach i realizacji własnego pomysłu, zamiast na zapamiętywaniu składni.
W Scratchu uczestnicy tworzą gry i interaktywne projekty, a następnie poznają App Inventor, w którym mogą projektować własne aplikacje mobilne. Z każdym kolejnym projektem pojawia się coraz więcej samodzielności i przestrzeni na własne rozwiązania.
Po tym kursie Twoje dziecko:
- stworzy własne gry, animacje i pierwsze aplikacje mobilne,
- pozna podstawowe mechanizmy programowania: zdarzenia, warunki, pętle i zmienne,
- nauczy się planować działanie projektu i krok po kroku realizować swój pomysł,
- będzie gotowe do przejścia do bardziej zaawansowanych form programowania.
Bloki są narzędziem. Najważniejsze jest to, że dziecko zaczyna rozumieć, jak działa program.
Program kursu:
Program kursu – Programowanie blokowe (Scratch, App Inventor)
Kurs prowadzi uczestników od pierwszych prostych mechanizmów programowania do tworzenia
własnych gier, animacji i aplikacji mobilnych. Pracujemy przede wszystkim w środowiskach
Scratch i MIT App Inventor, dzięki którym dzieci mogą skupić się
na logice programu, zależnościach i realizacji własnych pomysłów, zamiast na zapamiętywaniu składni.
Programowanie blokowe jest dla nas narzędziem do nauki myślenia programistycznego –
najważniejsze jest zrozumienie, jak zaplanować działanie projektu, przetestować je i poprawić.
1. Pierwsze kroki – od pomysłu do działającego programu
Zaczynamy od poznania środowiska Scratch i podstaw sterowania postaciami oraz obiektami.
Uczestnicy odkrywają, że nawet prosty projekt wymaga określenia kolejności działań i zależności
między poszczególnymi elementami.
Przykładowe projekty: animowana historia, interaktywna scena,
prosta gra zręcznościowa.
2. Zdarzenia i interakcje
Uczymy się tworzyć projekty reagujące na działania użytkownika – kliknięcie, naciśnięcie klawisza,
dotknięcie obiektu czy zmianę sytuacji w grze. Dzieci zaczynają rozumieć, że program może
odpowiadać na różne zdarzenia i wykonywać inne działania w zależności od tego, co zrobi gracz.
Przykładowe projekty: łapanie spadających obiektów, quiz,
interaktywna przygoda.
3. Warunki – program zaczyna podejmować decyzje
Wprowadzamy instrukcje warunkowe i sposób myślenia:
JEŻELI wydarzy się X → WTEDY wykonaj Y.
Dzięki temu gry i aplikacje zaczynają reagować na różne sytuacje.
Przykładowe projekty: labirynt, gra z przeszkodami,
system wygranej i przegranej.
4. Pętle – mniej bloków, więcej możliwości
Dzieci poznają pętle, które pozwalają automatycznie powtarzać określone działania.
Uczą się upraszczać swoje programy i zauważać powtarzalne schematy.
Przykładowe projekty: animacje, ruch przeciwników,
powtarzalne sekwencje i elementy gier zręcznościowych.
5. Zmienne, punkty i czas
Wprowadzamy zmienne, które pozwalają przechowywać informacje potrzebne w programie.
Uczestnicy wykorzystują je m.in. do zliczania punktów, czasu, życia gracza czy poziomu trudności.
Przykładowe projekty: gra na punkty, wyścig z czasem,
prosta gra z systemem żyć.
6. Coraz bardziej rozbudowane gry w Scratchu
Łączymy poznane wcześniej mechanizmy: zdarzenia, warunki, pętle, zmienne i interakcje.
Dzieci projektują gry z własnymi zasadami, poziomami trudności i mechaniką rozgrywki.
Przykładowe projekty: platformówka, zręcznościówka,
gra typu escape/maze, własna gra tematyczna.
7. Pierwsze aplikacje mobilne – App Inventor
Przechodzimy od gier i animacji do tworzenia aplikacji na urządzenia mobilne.
Uczestnicy poznają podstawy projektowania interfejsu, przyciski, pola tekstowe,
ekrany i reakcje aplikacji na działania użytkownika.
Przykładowe projekty: prosty kalkulator, quiz mobilny,
aplikacja z przyciskami i komunikatami.
8. Funkcje telefonu jako element projektu
W miarę możliwości projektu wykorzystujemy funkcje dostępne w urządzeniach mobilnych
i pokazujemy, że aplikacja może reagować na dane oraz działania użytkownika.
Uczestnicy uczą się planować przepływ informacji pomiędzy elementami aplikacji.
Przykładowe projekty: aplikacja użytkowa, mini-gra mobilna,
projekt wykorzystujący kilka ekranów.
9. Testowanie, poprawianie i debugowanie
Gotowy projekt nie zawsze działa od razu zgodnie z planem. Dzieci uczą się sprawdzać,
w którym miejscu pojawia się problem, analizować swoje bloki i testować kolejne rozwiązania.
Błąd traktujemy jak informację, która pomaga stworzyć lepszy projekt.
10. Od gotowych przykładów do własnego projektu
Wraz ze zdobywaniem doświadczenia uczestnicy otrzymują coraz więcej swobody.
Modyfikują przykładowe projekty, dodają własne mechanizmy i coraz częściej samodzielnie
decydują, jak osiągnąć zamierzony efekt.
Najpierw poznaję rozwiązania → potem zaczynam je rozumieć → w końcu wykorzystuję je po swojemu.
11. Projekt własny
Jednym z ważnych elementów kursu jest przygotowanie własnej gry, animacji lub aplikacji.
Uczestnik planuje projekt, wybiera potrzebne mechanizmy, tworzy go, testuje i wprowadza poprawki.
W trakcie kursu uczestnicy uczą się m.in.:
- tworzyć gry, animacje i aplikacje w środowiskach blokowych,
- korzystać ze zdarzeń, warunków, pętli i zmiennych,
- planować działanie programu krok po kroku,
- projektować prosty interfejs aplikacji,
- testować projekty i wyszukiwać błędy,
- modyfikować gotowe rozwiązania i rozwijać własne pomysły,
- coraz bardziej samodzielnie realizować własne projekty.
Przykładowe projekty realizowane podczas kursu:
animowana historia • quiz • labirynt • gra zręcznościowa • platformówka •
gra na punkty • wyścig z czasem • kalkulator mobilny • quiz mobilny •
mini-gra na telefon • własna gra lub aplikacja
Program ma charakter przykładowy. Kolejność projektów, wykorzystywane zadania i zakres zagadnień
mogą być modyfikowane w zależności od poziomu grupy, tempa pracy uczestników
oraz aktualizowanego programu zajęć.
Czas trwania zajęć: 90 minut.
Cena za zajęcia: 60,00 zł
Kwota opłaty miesięcznej może się zmieniać w zależności od ilości zajęć przypadających w danym miesiącu.
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Oferta na rok szkolny 2026/27
Grupa wiekowa: 9-12 lat
Tworzenie i programowanie gier w Roblox Studio
(Roblox Studio)
Kurs dla dzieci w wieku 9–12 lat, które chcą przejść od grania w Roblox do tworzenia własnych światów i gier.
Roblox Studio pozwala spojrzeć na popularną platformę zupełnie inaczej – od strony projektanta i programisty. Uczestnicy tworzą własne mapy, budują obiekty, projektują mechanikę rozgrywki oraz poznają podstawy języka Lua.
Zajęcia łączą programowanie z projektowaniem, kreatywnością i pracą nad coraz bardziej samodzielnymi projektami. Dziecko zaczyna rozumieć, że za każdą grą stoją zasady, kod, decyzje projektowe i wiele testów.
Po tym kursie Twoje dziecko:
- stworzy własną grę lub świat w Roblox Studio,
- pozna podstawy programowania w języku Lua,
- nauczy się projektować mapy,
- obiekty i mechanizmy rozgrywki,
- zacznie patrzeć na gry nie tylko jak gracz, ale również jak ich twórca.
Zamiast tylko grać w Roblox – zaczynamy rozumieć, jak własną grę można stworzyć.
Program kursu:
Program kursu – Tworzenie gier w Roblox Studio (Lua)
Kurs pokazuje Roblox od zupełnie innej strony – nie jako gotową grę, ale jako
środowisko do projektowania, programowania i tworzenia własnych światów.
Uczestnicy pracują w Roblox Studio, poznają podstawy języka Lua i krok po kroku
budują coraz bardziej rozbudowane mechaniki gry.
Najważniejszym celem jest przejście od gracza do twórcy:
dziecko zaczyna rozumieć, że za każdą grą stoją projekt, zasady, kod, testowanie i wiele decyzji.
1. Pierwszy własny świat w Roblox Studio
Poznajemy interfejs Roblox Studio, sposób poruszania się po scenie oraz podstawowe narzędzia.
Uczestnicy tworzą pierwszą mapę i uczą się dodawać, przesuwać, skalować i obracać obiekty.
Przykładowe projekty: własna wyspa, prosta mapa przygodowa,
pierwszy tor przeszkód.
2. Budujemy mapy i modele
Rozwijamy umiejętności projektowania świata. Uczestnicy poznają właściwości obiektów,
materiały, kolory i sposoby łączenia elementów w większe konstrukcje.
Zwracamy uwagę nie tylko na wygląd, ale także na funkcję projektu:
co gracz ma zrobić, gdzie ma dotrzeć i jak prowadzić go przez świat gry.
3. Pierwsze skrypty w Lua
Wprowadzamy język Lua i pokazujemy, w jaki sposób kod może zmieniać zachowanie obiektów w grze.
Zaczynamy od prostych instrukcji i reakcji, aby uczestnik szybko zobaczył efekt swojego programu.
Przykładowe projekty: znikający blok, ruchoma platforma,
obiekt zmieniający kolor lub właściwości.
4. Zmienne, warunki i zdarzenia
Uczestnicy uczą się przechowywać informacje w zmiennych, reagować na określone zdarzenia
oraz wykorzystywać warunki do sterowania przebiegiem gry.
Przykładowe mechaniki: punkty, aktywacja po dotknięciu obiektu,
otwieranie przejścia po spełnieniu warunku.
5. Pętle i automatyzacja
Poznajemy pętle i wykorzystujemy je do tworzenia powtarzalnych zachowań.
Dzieci uczą się upraszczać kod i projektować elementy, które działają automatycznie.
Przykładowe projekty: ruchome przeszkody, cykliczne platformy,
powtarzające się efekty i elementy świata.
6. Funkcje i porządkowanie kodu
Wprowadzamy funkcje jako sposób dzielenia większego programu na mniejsze, czytelne części.
Uczestnicy uczą się ponownie wykorzystywać fragmenty kodu i budować bardziej uporządkowane skrypty.
7. Mechanika gry – punkty, checkpointy i zasady
Tworzymy elementy, które sprawiają, że mapa staje się prawdziwą grą.
Projektujemy system punktów, checkpointy, warunki wygranej i przegranej oraz kolejne etapy rozgrywki.
Przykładowe projekty: Obby z checkpointami, zbieranie monet,
wyścig lub gra z określonym celem.
8. NPC, dialogi i zadania
Do świata dodajemy postacie niezależne oraz proste interakcje z graczem.
Uczestnicy poznają sposoby tworzenia dialogów, zadań i reakcji na działania użytkownika.
Przykładowe projekty: NPC zlecający misję, postać przekazująca wskazówki,
prosty quest.
9. Interfejs gracza
Poznajemy podstawy tworzenia elementów interfejsu – komunikatów, liczników, przycisków
i prostych paneli. Uczestnicy uczą się przekazywać graczowi informacje potrzebne podczas rozgrywki.
10. Animacje, efekty i klimat gry
Rozwijamy projekt o elementy wizualne i ruch. Pokazujemy, jak drobne detale wpływają
na odbiór świata i pomagają stworzyć bardziej angażującą rozgrywkę.
11. Testowanie i debugowanie
Każda gra wymaga testów. Uczestnicy sprawdzają, czy mechaniki działają zgodnie z planem,
czy poziom jest możliwy do przejścia i czy w kodzie nie pojawiły się błędy.
Nie poprawiamy wszystkiego za dziecko – uczymy, jak znaleźć przyczynę problemu
i sprawdzić własne rozwiązanie.
12. Projekt własnej gry
Uczestnicy wykorzystują zdobyte umiejętności do stworzenia bardziej samodzielnego projektu.
Planują mapę, mechanikę, wygląd świata i potrzebne skrypty, a następnie testują i rozwijają grę.
W trakcie kursu uczestnicy uczą się m.in.:
- pracować w środowisku Roblox Studio,
- projektować mapy, obiekty i proste poziomy,
- tworzyć pierwsze skrypty w języku Lua,
- korzystać ze zmiennych, warunków, pętli i funkcji,
- projektować mechanikę rozgrywki, punkty i checkpointy,
- tworzyć proste interakcje, NPC i zadania,
- testować i poprawiać własne gry,
- coraz bardziej samodzielnie realizować własne pomysły.
Przykładowe projekty realizowane podczas kursu:
Obby • mapa przygodowa • zbieranie monet • wyścig • ruchome platformy •
checkpointy • prosty quest • NPC z dialogiem • gra z punktami • własna gra w Roblox Studio
Program ma charakter przykładowy. Kolejność projektów, wykorzystywane mechaniki i zakres zagadnień
mogą być modyfikowane w zależności od poziomu grupy, tempa pracy uczestników
oraz aktualnych możliwości środowiska Roblox Studio.
Czas trwania zajęć: 90 minut.
Cena za zajęcia: 60,00 zł
Kwota opłaty miesięcznej może się zmieniać w zależności od ilości zajęć przypadających w danym miesiącu.
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Oferta na rok szkolny 2026/27
Grupa wiekowa: 9-12 lat
Kodowanie w Minecraft – programowanie blokowe
(Minecraft Education Edition)
Kurs dla dzieci w wieku 9–12 lat, które chcą rozpocząć naukę programowania w świecie Minecraft, który już znają i lubią.
Minecraft Education staje się tutaj środowiskiem do nauki kodowania. Uczestnicy korzystają z MakeCode i programowalnego Agenta, tworzą sekwencje poleceń, automatyzują zadania i programują rozwiązania wpływające bezpośrednio na świat gry.
Dzięki natychmiastowemu efektowi dziecko może szybko zobaczyć, czy jego pomysł działa. Jeśli nie – analizuje kod, poprawia go i próbuje ponownie. W ten sposób Minecraft staje się świetnym narzędziem do rozwijania logicznego myślenia i umiejętności rozwiązywania problemów.
Po tym kursie Twoje dziecko:
- stworzy pierwsze programy działające w świecie Minecraft,
- nauczy się wykorzystywać pętle, warunki, zmienne i współrzędne,
- zaprogramuje Agenta do wykonywania różnych zadań,
- będzie coraz bardziej samodzielnie planować i testować własne rozwiązania.
Od gracza do twórcy – świat Minecraft zaczyna reagować na kod napisany przez dziecko.
Czas trwania zajęć: 90 minut.
Cena za zajęcia: 60,00 zł
Kwota opłaty miesięcznej może się zmieniać w zależności od ilości zajęć przypadających w danym miesiącu.
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Oferta na rok szkolny 2026/27
Grupa wiekowa: 10-12 lat
Od programowania blokowego do tekstowego
(MakeCode, JavaScript, Python)
Kurs dla dzieci w wieku 10–12 lat, które znają już podstawy programowania blokowego i są gotowe na kolejny etap – prawdziwy kod.
To naturalny krok w rozwoju młodego programisty. Uczestnicy odkrywają, że mechanizmy poznane wcześniej – zmienne, warunki, pętle czy funkcje – występują również w programowaniu tekstowym. Zmienia się sposób ich zapisu, ale logika pozostaje ta sama.
Pracujemy m.in. z MakeCode, JavaScriptem i Pythonem. Nie zależy nam na zapamiętywaniu składni jednego języka. Chcemy, aby uczestnik nauczył się czytać kod, rozumieć jego działanie i samodzielnie tworzyć coraz bardziej rozbudowane rozwiązania.
Po tym kursie Twoje dziecko:
- napisze pierwsze programy w językach JavaScript i Python,
- zobaczy, jak przejść od programowania blokowego do tekstowego,
- nauczy się czytać, analizować i poprawiać własny kod,
- przygotuje się do dalszej nauki programowania tekstowego.
Język programowania może się zmienić. Sposób myślenia pozostaje.
Program kursu:
Program kursu – Od programowania blokowego do tekstowego (MakeCode, JavaScript, Python)
Kurs jest pomostem pomiędzy programowaniem blokowym a pierwszą samodzielną pracą z kodem tekstowym.
Uczestnicy odkrywają, że mechanizmy znane ze Scratcha czy MakeCode – zmienne, warunki,
pętle i funkcje – działają również w językach tekstowych.
Pracujemy m.in. z MakeCode, JavaScriptem i Pythonem.
Nie uczymy składni na pamięć – uczymy rozumieć kod, analizować jego działanie
i stopniowo coraz bardziej samodzielnie zapisywać własne rozwiązania.
1. Ten sam pomysł, inny zapis
Zaczynamy od porównywania programów blokowych z ich odpowiednikami w kodzie tekstowym.
Uczestnicy obserwują, że logika programu pozostaje taka sama, choć sposób zapisu się zmienia.
2. Pierwsze instrukcje i zmienne
Poznajemy podstawową składnię oraz sposób przechowywania informacji w zmiennych.
Tworzymy pierwsze krótkie programy, które wykonują obliczenia, zapisują dane i wyświetlają wyniki.
Przykładowe projekty: prosty kalkulator, licznik,
program przeliczający wartości.
3. Wejście i wyjście – program rozmawia z użytkownikiem
Uczestnicy uczą się pobierać dane od użytkownika i wykorzystywać je w programie.
Powstają pierwsze interaktywne projekty tekstowe.
Przykładowe projekty: rozmowna konsola, generator komunikatów,
prosty formularz tekstowy.
4. Warunki – program podejmuje decyzje
Wprowadzamy instrukcje warunkowe i tworzymy programy reagujące na różne dane.
Uczestnicy uczą się budować kilka możliwych ścieżek działania.
Przykładowe projekty: proste logowanie, quiz,
gra z wyborem odpowiedzi.
5. Pętle – program wykonuje zadanie wielokrotnie
Poznajemy pętle i wykorzystujemy je do powtarzania określonych działań,
przetwarzania kolejnych danych i tworzenia mechanizmów działających do momentu spełnienia warunku.
Przykładowe projekty: zgadywanie liczby, powtarzany quiz,
proste menu programu.
6. Losowość i pierwsze proste gry
Wprowadzamy wartości losowe i wykorzystujemy je w projektach, które za każdym uruchomieniem
mogą działać trochę inaczej.
Przykładowe projekty: kostka do gry, generator losowań,
prosta gra tekstowa.
7. Funkcje – porządkujemy program
Uczestnicy poznają funkcje i uczą się dzielić większy program na mniejsze,
czytelniejsze fragmenty odpowiadające za konkretne zadania.
Pokazujemy, że dobrze zaplanowany kod jest łatwiejszy do rozwijania i poprawiania.
8. Listy i praca z większą liczbą danych
Poznajemy podstawy kolekcji danych i sposoby przechowywania większej liczby wartości.
Uczestnicy uczą się przeglądać dane, zmieniać je i wykorzystywać w programie.
Przykładowe projekty: lista wyników, prosty ranking,
zestaw pytań do quizu.
9. JavaScript – kod działający w praktyce
Wykorzystujemy JavaScript do utrwalania poznanych mechanizmów i pokazujemy,
jak blokowy sposób myślenia można przełożyć na kod tekstowy.
Uczestnicy tworzą krótkie programy i zadania wymagające samodzielnego zapisania rozwiązania.
10. Python – kolejny język, te same fundamenty
Przechodzimy do Pythona i porównujemy jego zapis z wcześniej poznanymi rozwiązaniami.
Uczestnicy zauważają, że język może się zmienić, ale pojęcia takie jak zmienna,
warunek, pętla czy funkcja nadal pozostają podstawą programu.
Przykładowe projekty: kalkulator, gra „zgadnij liczbę”,
prosty quiz, mini-gra tekstowa.
11. Debugowanie – czytamy kod i szukamy przyczyny
Uczestnicy uczą się czytać komunikaty o błędach, analizować fragmenty programu
i systematycznie sprawdzać, dlaczego kod nie działa zgodnie z założeniem.
Umiejętność znalezienia błędu traktujemy jako część programowania, a nie jako porażkę.
12. Coraz więcej samodzielności
W kolejnych zadaniach uczestnik otrzymuje cel, ale coraz mniej gotowego kodu.
Sam dobiera poznane mechanizmy, planuje rozwiązanie i testuje własny program.
13. Projekt końcowy
Na zakończenie uczestnicy wykorzystują poznane elementy do stworzenia bardziej samodzielnego projektu:
gry tekstowej, aplikacji konsolowej lub innego programu odpowiadającego poziomowi grupy.
W trakcie kursu uczestnicy uczą się m.in.:
- przechodzić od bloków do kodu tekstowego,
- czytać i pisać proste programy w JavaScript i Pythonie,
- korzystać ze zmiennych, warunków, pętli, funkcji i list,
- pobierać dane od użytkownika i wykorzystywać je w programie,
- planować rozwiązanie przed napisaniem kodu,
- czytać komunikaty o błędach i debugować program,
- coraz bardziej samodzielnie tworzyć własne programy.
Przykładowe projekty realizowane podczas kursu:
kalkulator • proste logowanie • quiz • zgadywanie liczby • generator losowań •
gra tekstowa • ranking wyników • program z menu • mini-projekt w JavaScript •
mini-projekt w Pythonie • własny projekt końcowy
Program ma charakter przykładowy. Kolejność projektów, wykorzystywane języki i zakres zagadnień
mogą być modyfikowane w zależności od poziomu grupy, tempa pracy uczestników
oraz aktualizowanego programu zajęć.
czas trwania zajęć: 90 minut
Cena za zajęcia: 60,00 zł
Kwota opłaty miesięcznej może się zmieniać w zależności od ilości zajęć przypadających w danym miesiącu.
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Oferta na rok szkolny 2026/7
Grupa wiekowa: 10-12 lat
Tworzenie i programowanie gier 2D
(Unity 3D)
Kurs dla dzieci i młodzieży, które chcą nauczyć się tworzyć własne gry komputerowe w profesjonalnym środowisku Unity.
Unity pozwala zobaczyć, jak wygląda tworzenie gry od strony jej autora. Uczestnicy projektują sceny, dodają obiekty, określają zasady rozgrywki, programują zachowanie elementów i testują własne rozwiązania.
Tworzenie gry łączy wiele umiejętności jednocześnie: programowanie, logiczne myślenie, projektowanie, kreatywność i rozwiązywanie problemów. Każdy projekt wymaga planu, wielu prób i poprawek – dokładnie tak, jak podczas pracy nad prawdziwą grą.
Po tym kursie Twoje dziecko:
- stworzy własne projekty gier w środowisku Unity,
- pozna podstawy projektowania poziomów i mechaniki rozgrywki,
- nauczy się programować zachowanie elementów gry,
- zacznie rozumieć, jak powstają gry, w które na co dzień gra.
Gra przestaje być gotowym produktem na ekranie. Staje się projektem, który można samodzielnie stworzyć.
Program kursu:
Program kursu – Tworzenie i programowanie gier 2D/3D (Unity)
Kurs pokazuje, jak wygląda tworzenie gry od strony projektanta i programisty. Pracujemy w środowisku Unity, wykorzystywanym do tworzenia gier i aplikacji interaktywnych. Uczestnicy projektują sceny, dodają obiekty, tworzą mechanikę rozgrywki i stopniowo poznają podstawy programowania potrzebne do sterowania grą.
Nie chodzi o samo „zrobienie gry”. Uczymy planować projekt, łączyć grafikę z logiką, testować mechaniki i poprawiać rozwiązania tak, jak robi się to w prawdziwym procesie tworzenia gier.
1. Pierwszy projekt w Unity
Poznajemy interfejs programu, scenę, obiekty i podstawowy sposób pracy w środowisku Unity. Uczestnicy tworzą pierwszy projekt i uczą się organizować elementy gry.
2. Scena, obiekty i komponenty
Uczymy się dodawać obiekty, zmieniać ich właściwości i budować scenę. Poznajemy ideę komponentów, dzięki którym obiekty mogą otrzymywać konkretne funkcje.
Przykładowe zadania: budowa pierwszego poziomu, tworzenie przeszkód, ustawianie kamery.
3. Ruch gracza i pierwsze skrypty
Wprowadzamy proste skrypty odpowiedzialne za sterowanie postacią. Uczestnicy widzą, jak kod wpływa bezpośrednio na zachowanie obiektu w grze.
Przykładowe projekty: poruszanie postacią, skok, sterowanie obiektem.
4. Fizyka, kolizje i triggery
Poznajemy podstawowe elementy fizyki w grze, kolizje oraz triggery. Uczestnicy uczą się wykrywać kontakt pomiędzy obiektami i uruchamiać określone reakcje.
Przykładowe mechaniki: zbieranie przedmiotów, strefa końca poziomu, przeszkody i pułapki.
5. Punkty, życie i zasady rozgrywki
Tworzymy podstawowe systemy gry: punkty, życie gracza, warunki wygranej i przegranej. Dzieci zaczynają planować nie tylko wygląd poziomu, ale także jego reguły.
6. Projektowanie poziomów
Uczestnicy uczą się budować poziomy, które są czytelne, możliwe do przejścia i stopniowo zwiększają poziom trudności.
Rozmawiamy o tym, jak prowadzić gracza przez świat i jak sprawić, żeby projekt był ciekawy, ale jednocześnie zrozumiały.
7. Interfejs użytkownika
Dodajemy do gry elementy UI: licznik punktów, komunikaty, ekran startowy, informację o wygranej lub przegranej i proste przyciski.
8. Przeciwnicy i ruchome elementy
Tworzymy obiekty poruszające się według określonych zasad oraz pierwszych przeciwników. Uczestnicy poznają sposoby programowania reakcji i prostych zachowań.
Przykładowe projekty: patrolujący przeciwnik, ruchoma platforma, obiekt podążający określoną trasą.
9. Dźwięk, animacje i klimat gry
Rozwijamy projekt o dźwięki, proste animacje i efekty, które zwiększają czytelność oraz atrakcyjność rozgrywki. Uczestnicy uczą się, że dobra gra to połączenie wielu elementów.
10. Od gry 2D do elementów 3D
W zależności od poziomu grupy pokazujemy różnice pomiędzy projektowaniem w 2D i 3D oraz wprowadzamy pierwsze elementy przestrzenne, kamerę i pracę z obiektami 3D.
11. Testowanie i balans gry
Gotowa mechanika wymaga testów. Sprawdzamy, czy gra jest możliwa do przejścia, czy poziom trudności jest odpowiedni i czy poszczególne elementy działają zgodnie z planem.
Uczestnicy uczą się, że pierwsza wersja projektu bardzo rzadko jest wersją ostateczną.
12. Debugowanie
Szukamy błędów w kodzie i konfiguracji obiektów. Uczestnicy uczą się analizować, czy problem wynika ze skryptu, ustawień komponentu, fizyki czy konstrukcji sceny.
13. Własny projekt gry
Na zakończenie uczestnicy planują i rozwijają własny projekt: wybierają rodzaj gry, projektują poziom, tworzą mechanikę, dodają interfejs i testują działanie całości.
Celem jest przejście od „gram w gry” do „rozumiem, z czego gra jest zbudowana i potrafię stworzyć własny projekt”.
W trakcie kursu uczestnicy uczą się m.in.:
- pracować w środowisku Unity,
- tworzyć sceny, obiekty i poziomy,
- dodawać komponenty i programować podstawowe zachowania,
- korzystać z fizyki, kolizji i triggerów,
- tworzyć system punktów, życia i warunki gry,
- projektować prosty interfejs użytkownika,
- testować, balansować i debugować projekt,
- coraz bardziej samodzielnie tworzyć własną grę.
Przykładowe projekty realizowane podczas kursu:
prosta platformówka • gra ze zbieraniem punktów • tor przeszkód •
labirynt • gra z przeciwnikiem • poziom z ruchomymi platformami •
mini-gra 2D • pierwszy projekt 3D • własna gra
Program ma charakter przykładowy. Kolejność projektów, wykorzystywane mechaniki i zakres zagadnień mogą być modyfikowane w zależności od poziomu grupy, tempa pracy uczestników oraz aktualizowanego programu zajęć.
czas trwania zajęć: 90 minut
Cena za zajęcia: 60,00 zł
Kwota opłaty miesięcznej może się zmieniać w zależności od ilości zajęć przypadających w danym miesiącu.
Zniżki:
– 10% zniżki dla każdego z rodzeństwa, uczęszczającego w tym samym terminie.
– 10% zniżki dla posiadaczy karty „Duża Rodzina”.
– 10% zniżki na drugie i kolejne zajęcia w tym samym czasie.
Zniżki nie łączą się ze sobą.Zajęcia trwają cały rok szkolny i odbywają się raz w tygodniu.
Dlaczego warto wybrać programowanie w Akademii EMT KIDS?
- Różne technologie – wspólny cel
Scratch, App Inventor, Roblox Studio, Minecraft, JavaScript, Python czy Unity są dla nas narzędziami. Nie uczymy dzieci jednego programu „na pamięć”. Pokazujemy różne sposoby tworzenia i rozwijamy logiczne myślenie, samodzielność oraz umiejętność rozwiązywania problemów. - Ścieżka, która może rozwijać się razem z dzieckiem
Uczestnik może rozpocząć od programowania blokowego, tworzenia gier czy Minecrafta, a następnie przechodzić do programowania tekstowego i coraz bardziej zaawansowanych projektów. Dzięki temu kolejne kursy mogą być naturalnym etapem dalszego rozwoju. - Tworzymy, zamiast tylko odtwarzać
Gotowe przykłady są początkiem, a nie celem zajęć. Wraz ze zdobywaniem doświadczenia dzieci coraz częściej modyfikują projekty, podejmują własne decyzje i realizują własne pomysły. - Trener pomaga, ale nie wyręcza
Podpowiadamy, naprowadzamy i wspólnie analizujemy problemy, ale zależy nam, aby uczestnik sam dochodził do rozwiązania. To właśnie wtedy rozwija się sprawczość, wytrwałość i prawdziwa samodzielność. - Technologia + doświadczenie edukacyjne
Za Akademią EMT KIDS stoją EMT-Systems oraz Akademia Nauki i Rozwoju. Łączymy technologiczne zaplecze i doświadczenie w szkoleniach technicznych z wieloletnią praktyką w edukacji dzieci i młodzieży.
Proste zasady dla rodziców - Najpierw zajęcia próbne, potem decyzja
Dziecko może najpierw przetestować zajęcia. Umowę podpisujemy dopiero po pierwszym spotkaniu. Jeśli nie chce kontynuować – nie pobieramy za nie opłaty. Jeśli zostaje, pierwsze zajęcia wliczamy do harmonogramu płatności. - Bez zobowiązania na cały rok szkolny
Umowę można wypowiedzieć w dowolnym momencie ze skutkiem na koniec danego miesiąca. Nie naliczamy kar ani dodatkowych opłat za wcześniejszą rezygnację. - Płacisz za zajęcia, które faktycznie się odbywają
Miesięczna opłata zależy od liczby zajęć przypadających w danym miesiącu. Nie płacisz za święta, ferie, wakacje ani inne dni, w których zgodnie z harmonogramem zajęcia się nie odbywają. - 10% zniżki
Oferujemy 10% zniżki dla rodzeństwa, posiadaczy Karty Dużej Rodziny oraz na drugie i kolejne zajęcia.
Nie wiemy, jakie technologie będą dominować za kilkanaście lat. Dlatego zamiast przywiązywać dzieci do jednego narzędzia, uczymy je myśleć, tworzyć i odnajdywać się w świecie technologii.