C# RUSZ GŁOWĄ WYD.IV

SPIS TREŚCI

Wprowadzenie

• Dla kogo przeznaczona jest ta książka? (xxx)
• Wiemy, co sobie myślisz (xxxi)
• Wiemy, co sobie myśli Twój mózg (xxxi)
• Metapoznanie – myślenie o myśleniu (xxxiii)
• Oto co zrobiliśmy (xxxiv)
• Oto co możesz zrobić, aby zmusić swój mózg do posłuszeństwa (xxxv)
• Przeczytaj to (xxxvi)
• Zespół redaktorów merytorycznych xxxiii)
• Podziękowania (xxxix)

ROZDZIAŁ 1. Zacznij pisać programy w języku C#. Utwórz coś wspaniałego… i to szybko

• Dlaczego warto opanować C#? (2)
• Visual Studio jest narzędziem do pisania kodu oraz poznawania języka C# (3)
• Utwórz pierwszy projekt w Visual Studio (4)
• Napiszmy grę! (6)
• Proces tworzenia gry (7)
• Utwórz projekt WPF w Visual Studio (8)
• Użyj języka XAML do zaprojektowania okna (12)
• Zaprojektuj okno gry (13)
• Ustaw wielkość okna i podaj nagłówek za pomocą właściwości w XAML-u (14)
• Dodaj wiersze i kolumny do siatki w XAML-u (16)
• Wyrównaj wielkości wierszy i kolumn (17)
• Dodaj kontrolki TextBlock do siatki (18)
• Teraz możesz zacząć pisać kod gry (21)
• Wygeneruj metodę konfigurującą grę (22)
• Dokończ metodę SetUpGame (24)
• Uruchom program (26)
• Dodaj nowy projekt do systemu kontroli wersji (30)
• Następny krok tworzenia gry to dodanie obsługi kliknięć myszą (33)
• Spraw, aby kontrolki TextBlock reagowały na kliknięcia myszą (34)
• Dodaj kod metody TextBlock_MouseDown (37)
• Spraw, aby pozostałe kontrolki TextBlock wywoływały tę samą procedurę obsługi zdarzeń MouseDown (38)
• Ukończ grę, dodając zegar (39)
• Dodaj zegar do kodu gry (40)
• Użyj debugera do znalezienia przyczyny wyjątku (42)
• Dodaj resztę kodu i dokończ grę (46)
• Aktualizowanie kodu w systemie kontroli wersji (47)

ROZDZIAŁ 2. Zanurz się w C#. Instrukcje, klasy i kod

• Przyjrzyj się plikom aplikacji konsolowej (50)
• W jednej przestrzeni nazw (i jednym pliku!) mogą się znajdować dwie klasy (52)
• Instrukcje są cegiełkami do tworzenia aplikacji (55)
• Programy używają zmiennych do pracy z danymi (56)
• Generowanie nowej metody używającej zmiennych (58)
• Dodaj do metody kod używający operatorów (59)
• Używanie debugera do obserwowania zmian zmiennych (60)
• Używanie operatorów do pracy ze zmiennymi (62)
• Instrukcje if służą do podejmowania decyzji (63)
• Pętle powtarzają wykonywanie operacji (64)
• Używanie fragmentów kodu do pisania pętli (67)
• Mechanika interfejsów użytkownika zależy od kontrolek (71)
• Tworzenie aplikacji WPF do eksperymentowania z kontrolkami (72)
• Dodawanie kontrolki TextBox do aplikacji (75)
• Dodawanie kodu C# do obsługi kontrolki TextBlock (77)
• Dodawanie procedury obsługi zdarzeń dopuszczającej tylko dane liczbowe (79)
• Dodawanie suwaków w dolnym wierszu siatki (83)
• Dodawanie kodu C# do obsługi pozostałych kontrolek (84)

ĆWICZENIA z Unity nr 1. Poznawaj C# z Unity

• Unity jest rozbudowanym narzędziem do projektowania gier (88)
• Pobieranie Unity Hub (89)
• Używanie Unity Hub do tworzenia nowego projektu (90)
• Przejmij kontrolę nad układem Unity (91)
• Sceną jest środowisko 3D (92)
• Gry Unity są tworzone za pomocą obiektów gry (GameObject) (93)
• Używanie narzędzia przenoszenia do przesuwania obiektów gry (94)
• Okno Inspector wyświetla komponenty obiektów gry (95)
• Określ materiał kuli (96)
• Obracanie kuli (99)
• Bądź kreatywny! (102)

ROZDZIAŁ 3. Obiekty – orientuj się! Aby kod miał sens

• Jeśli kod jest przydatny, można ponownie go wykorzystać (104)
• Niektóre metody przyjmują parametry i zwracają wartość (105)
• Napisz program, który wybiera karty (106)
• Utwórz aplikację konsolową PickRandomCards (107)
• Dokończ metodę PickSomeCards (108)
• Gotowa klasa CardPicker (110)
• Ania pracuje nad następną grą (113)
• Przygotuj papierowy prototyp klasycznej gry (116)
• Następny krok: zbuduj wersję WPF aplikacji do wybierania kart (118)
• StackPanel to kontener rozmieszczający inne kontrolki jedna nad drugą (119)
• Ponownie wykorzystaj klasę CardPicker w nowej aplikacji WPF (120)
• Użyj siatki i kontrolki StackPanel do określenia układu głównego okna (121)
• Przygotuj układ okna aplikacji desktopowej do wybierania kart (122)
• Ania może użyć obiektów do rozwiązania problemu (126)
• Klasa służy do tworzenia obiektów (127)
• Gdy tworzysz nowy obiekt na podstawie klasy, jest on nazywany jej instancją (128)
• Lepsze rozwiązanie dla Ani – wszystko dzięki obiektom (129)
• Instancja używa pól do śledzenia stanu (133)
• Dziękujemy za pamięć (136)
• Co program ma na myśli (137)
• Czasem kod jest mało czytelny (138)
• Używaj zrozumiałych nazw klas i metod (140)
• Zbuduj klasę reprezentującą ludzi (146)
• Istnieje łatwiejszy sposób na inicjowanie obiektów w C# (148)
• Użyj okna C# Interactive do uruchamiania kodu C# (154)

ROZDZIAŁ 4. Typy i referencje. Pobieranie referencji

• Oskar potrzebuje naszej pomocy! (156)
• Karty postaci służą do zapisywania różnych danych na kartce (157)
• Typ zmiennej określa, jakiego rodzaju dane może ona przechowywać (158)
• C# udostępnia kilka typów do przechowywania liczb całkowitych (159)
• Porozmawiajmy o łańcuchach znaków (161)
• Literał to wartość bezpośrednio zapisana w kodzie (162)
• Zmienne są jak kubek na dane (165)
• Także inne typy mają różne rozmiary (166)
• 10 kilogramów danych w 5-kilogramowej torbie (167)
• Rzutowanie umożliwia kopiowanie wartości, których C# nie potrafi automatycznie przekształcić na inny typ (168)
• C# niektóre konwersje przeprowadza automatycznie (171)
• Gdy wywołujesz metodę, argumenty muszą być zgodne z typami parametrów (172)
• Pomóżmy Oskarowi w eksperymentach z punktami umiejętności (176)
• Użyj kompilatora C# do znalezienia błędnego wiersza kodu (178)
• Używaj zmiennych referencyjnych, aby uzyskać dostęp do obiektów (186)
• Wiele referencji i ich efekty uboczne (190)
• Obiekty komunikują się między sobą za pomocą referencji (198)
• Tablice przechowują wiele wartości (200)
• Tablice mogą zawierać zmienne referencyjne (201)
• null oznacza referencję, która nic nie wskazuje (203)
• Witaj w Budżetowych Kanapkach Jarka Niechluja (208)

ĆWICZENIA z Unity nr 2. Pisanie kodu C# w Unity

• Skrypty C# odpowiadają za działanie obiektów gry (214)
• Dodaj skrypt C# do obiektu gry (215)
• Napisz kod C# do rotowania kuli (216)
• Dodaj punkt przerwania i zdebuguj grę (218)
• Użyj debugera, aby zrozumieć działanie wartości Time.deltaTime (219)
• Dodaj walec, aby zobaczyć, gdzie znajduje się oś Y (220)
• Dodaj do klasy pola określające kąt i szybkość rotacji (221)
• Użyj wywołania Debug.DrawRay, aby zbadać działanie wektorów trójwymiarowych (222)
• Uruchom grę, aby zobaczyć promień w widoku Scene (223)
• Rotowanie bili względem punktu sceny (224)
• Użyj Unity, aby przyjrzeć się rotacji i wektorom (225)
• Bądź kreatywny! (226)

ROZDZIAŁ 5. Hermetyzacja. Zapewnij prywatność swoich sekretów

• Pomóż Oskarowi w definiowaniu rzutów obrażeń (228)
• Napisz aplikację konsolową do obliczania obrażeń (229)
• Zaprojektuj kod XAML dla wersji WPF kalkulatora obrażeń (231)
• Kod zaplecza kalkulatora obrażeń (232)
• Rozmowy przy stole (a może – dyskusja nad kostkami?) (233)
• Spróbuj wyeliminować błąd (234)
• Użyj metody Debug.WriteLine do wyświetlania informacji diagnostycznych (235)
• Łatwo jest przypadkowo błędnie użyć obiektów (238)
• Hermetyzacja oznacza utworzenie niektórych danych klasy jako prywatnych (239)
• Użyj hermetyzacji do kontrolowania dostępu do metod i pól klasy (240)
• Ale czy pole RealName NAPRAWDĘ jest chronione? (241)
• Prywatne pola i metody są dostępne tylko w instancjach tej samej klasy (242)
• Po co jest hermetyzacja? Potraktuj obiekt jak czarną skrzynkę… (247)
• Zastosuj hermetyzację, aby ulepszyć klasę SwordDamage (251)
• Hermetyzacja zapewnia bezpieczeństwo danych (252)
• Napisz aplikację konsolową do testowania klasy PaintballGun (253)
• Właściwości ułatwiają hermetyzację (254)
• Zmodyfikuj metodę Main, aby używała właściwości Balls (255)
• Automatycznie implementowane właściwości upraszczają kod (256)
• Użyj prywatnego settera, aby utworzyć właściwość tylko do odczytu (257)
• Co zrobić, aby zmienić pojemność magazynka? (258)
• Do inicjowania właściwości użyj konstruktora z parametrami (259)
• Podaj argumenty, gdy używasz słowa kluczowego new (260)

ROZDZIAŁ 6. Dziedziczenie. Drzewo genealogiczne obiektów

• Obliczanie obrażeń od DODATKOWYCH broni (274)
• Użyj instrukcji switch do dopasowywania wartości (275)
• Jeszcze jedna sprawa – czy możemy obliczyć obrażenia od sztyletu? I od buławy? (277)
• Zastosowanie dziedziczenia pozwala napisać kod tylko raz (278)
• Zbuduj model klas, zaczynając od klas ogólnych i przechodząc do bardziej wyspecjalizowanych (279)
• Jak zaprojektujesz symulator zoo? (280)
• Każda podklasa rozszerza klasę bazową (285)
• Użyj dwukropka, aby rozszerzyć klasę bazową (290)
• W podklasie można przesłaniać metody, aby modyfikować lub zastępować odziedziczone składowe (292)
• Niektóre składowe są implementowane tylko w podklasie (297)
• Użyj debugera, aby zrozumieć przesłanianie (298)
• Zbuduj aplikację, aby lepiej poznać słowa kluczowe virtual i override (300)
• Podklasa może ukrywać metody z klasy bazowej (302)
• Używaj słów kluczowych override i virtual do dziedziczenia operacji (304)
• Gdy klasa bazowa zawiera konstruktor, w podklasie trzeba go wywołać (307)
• Pora ukończyć zadanie dla Oskara (309)
• Zbuduj system zarządzania rojem pszczół (316)
• Klasa Queen – jak królowa zarządza robotnicami? (318)
• Interfejs użytkownika: dodaj kod XAML głównego okna (319)
• Sprzężenie zwrotne wpływa na grę w zarządzanie rojem (328)
• Na podstawie niektórych klas nigdy nie należy tworzyć obiektów (332)
• Klasy abstrakcyjne celowo są niekompletne (334)
• Jak wspominaliśmy, niektórych klas nie należy używać do tworzenia obiektów (336)
• Metoda abstrakcyjna nie ma ciała (337)
• Właściwości abstrakcyjne działają tak jak metody abstrakcyjne (338)

ĆWICZENIA z Unity nr 3. Instancje obiektów gry

• Zbudujmy grę w Unity! (344)
• Utwórz nowy materiał w katalogu Materials (345)
• Wygeneruj bilę w losowym punkcie sceny (346)
• Użyj debugera, aby zrozumieć wywołanie Random.value (347)
• Przekształć obiekt gry w obiekt prefab (348)
• Utwórz skrypt do sterowania grą (349)
• Dołącz skrypt do głównej kamery (350)
• Wciśnij Play, aby uruchomić kod (351)
• Użyj okna Inspector do pracy z instancjami obiektów gry (352)
• Wykorzystaj silnik fizyki, aby uniknąć pokrywania się bil (353)
• Bądź kreatywny! (354)

ROZDZIAŁ 7. Interfejsy, rzutowanie i instrukcja „is”. Spełnianie obietnic przez klasy

• Rój został zaatakowany! (356)
• Można zastosować rzutowanie, aby wywołać metodę DefendHive (357)
• Interfejs definiuje metody i właściwości, jakie klasa musi implementować (358)
• Nabierz wprawy w używaniu interfejsów (360)
• Nie możesz utworzyć obiektu typu interfejsu, ale możesz utworzyć referencję do interfejsu (366)
• Referencje typów interfejsowych są zwykłymi referencjami do obiektów (369)
• RoboPszczoła 4000 potrafi wykonywać pracę robotnic bez zużywania cennego miodu (370)
• Właściwość Job interfejsu IWorker to prowizorka (374)
• Do sprawdzania typu obiektu użyj instrukcji „is” (375)
• Użyj „is” do uzyskania dostępu do metod w podklasie (376)
• Co zrobić, jeśli inne zwierzęta też mają pływać lub polować w stadzie? (378)
• Używaj interfejsów do pracy z klasami, które wykonują to samo zadanie (379)
• Bezpiecznie poruszaj się po hierarchii klas za pomocą instrukcji „is” (380)
• C# udostępnia też inne narzędzie do bezpiecznej konwersji typów: słowo kluczowe „as” (381)
• Stosuj rzutowanie w górę i w dół, aby poruszać się po hierarchii klas (382)
• Rzutowanie w górę przekształca obiekt typu CoffeeMaker w obiekt typu Appliance (384)
• Rzutowanie w dół zmienia obiekt typu Appliance ponownie w obiekt typu CoffeeMaker (385)
• Rzutowanie w górę i w dół działa także dla interfejsów (386)
• Interfejsy mogą dziedziczyć po innych interfejsach (388)
• Interfejsy mogą zawierać składowe statyczne (395)
• Domyślne implementacje zawierają ciało metod interfejsów (396)
• Dodaj metodę ScareAdults z implementacją domyślną (397)
• Wiązanie danych powoduje automatyczną aktualizację kontrolek WPF (399)
• Zmodyfikuj system zarządzania rojem, aby używał wiązania danych (400)
• Polimorfizm oznacza, że jeden obiekt może przyjmować wiele różnych postaci (403)

ROZDZIAŁ 8. Wyliczenia i kolekcje. Porządkowanie danych

• Łańcuchy znaków nie zawsze nadają się do przechowywania kategorii danych (406)
• Wyliczenia umożliwiają pracę ze zbiorem poprawnych wartości (407)
• Wyliczenia umożliwiają reprezentowanie liczb za pomocą nazw (408)
• Moglibyśmy użyć tablicy do tworzenia talii kart… (411)
• Listy umożliwiają łatwe przechowywanie kolekcji czegokolwiek (413)
• Listy dają więcej możliwości niż tablice (414)
• Utwórzmy aplikację do przechowywania butów (417)
• Generyczne kolekcje mogą przechowywać wartości dowolnego typu (420)
• Inicjalizatory kolekcji są podobne do inicjalizatorów obiektów (426)
• Utwórzmy listę kaczek (427)
• Listy są proste, ale SORTOWANIE bywa skomplikowane (428)
• Interfejs IComparable pomaga liście sortować kaczki (429)
• Użyj obiektu typu IComparer, aby poinformować listę, jak sortować elementy (430)
• Utwórz obiekt komparatora (431)
• Przesłonienie metody ToString umożliwia obiektowi opisywanie samego siebie (435)
• Zaktualizuj pętle foreach, aby obiekty typów Duck i Card wyświetlały informacje o sobie w konsoli (436)
• Możesz zrzutować w górę całą listę, używając interfejsu IEnumerable (440)
• Użyj słownika do przechowywania kluczy i wartości (442)
• Przegląd możliwości słowników (443)
• Napisz program używający słownika (444)
• Jeszcze WIĘCEJ typów kolekcji… (445)
• Kolejka to kolekcja typu FIFO (first in, first out) (446)
• Stos to kolekcja typu LIFO (last in, last out) (447)
• Ćwiczenie do pobrania – dwie talie (452)

ĆWICZENIA z Unity nr 4. Interfejsy użytkownika

• Dodaj wynik zwiększany po kliknięciu bili przez gracza (454)
• Dodaj dwa różne tryby gry (455)
• Dodaj tryb gry (456)
• Dodaj interfejs użytkownika do gry (458)
• Skonfiguruj obiekt Text wyświetlający wynik w interfejsie użytkownika (459)
• Dodaj przycisk, który wywołuje metodę uruchamiającą grę (460)
• Dodaj kod obsługi przycisku Zagraj ponownie i pola z wynikiem (461)
• Dokończ kod gry (462)
• Wykaż się kreatywnością! (466)

ROZDZIAŁ 9. LINQ i lambdy. Kontroluj swoje dane

• Jacek jest wielkim fanem Kapitana Wspaniałego (468)
• Użyj technologii LINQ do pisania kwerend dotyczących kolekcji (470)
• LINQ działa dla każdego obiektu z implementacją interfejsu IEnumerable (472)
• Składnia kwerend LINQ (475)
• LINQ działa dla obiektów (477)
• Użyj kwerendy LINQ do ukończenia aplikacji dla Jacka (478)
• Słowo kluczowe var powoduje, że C# wywnioskowuje typy zmiennych (480)
• Kwerendy LINQ są wykonywane dopiero, gdy chcesz użyć ich wyników (487)
• Użyj kwerendy grupującej do rozdzielenia sekwencji na grupy (488)
• Użyj kwerend złączających do scalania danych z dwóch sekwencji (491)
• Użyj słowa kluczowego new do utworzenia typu anonimowego (492)
• Dodaj projekt z testami jednostkowymi do aplikacji zarządzającej kolekcją komiksów Jacka (502)
• Napisz pierwszy test jednostkowy (503)
• Napisz test jednostkowy metody GetReviews (505)
• Napisz testy jednostkowe uwzględniające przypadki brzegowe i nietypowe dane (506)
• Użyj operatora => do tworzenia wyrażeń lambda (508)
• Jazda próbna z lambdami (509)
• Refaktoryzacja kodu dotyczącego klaunów za pomocą lambd (510)
• Użyj operatora ?: do podejmowania decyzji w lambdach (513)
• Wyrażenia lambda i LINQ (514)
• Kwerendy LINQ można zapisywać jako łańcuch metod LINQ (515)
• Użyj operatora => do tworzenia wyrażeń switch (517)
• Omówienie klasy Enumerable (521)
• Ręczne tworzenie sekwencji umożliwiającej wyliczanie (522)
• Użyj instrukcji yield return do tworzenia własnych sekwencji (523)
• Użyj instrukcji yield return, aby zrefaktoryzować klasę ManualSportSequence (524)
• Ćwiczenie do pobrania: Go Fish (527)

ROZDZIAŁ 10. Odczyt i zapis plików. Zachowaj dla mnie ostatni bajt

• W .NET do odczytu i zapisu danych używane są strumienie (530)
• Różne strumienie wczytują i zapisują różne dane (531)
• Klasa FileStream wczytuje i zapisuje bajty w plikach (532)
• Zapis tekstu w pliku w trzech prostych krokach (533)
• Kanciarz realizuje następny diaboliczny plan (534)
• Użyj klasy StreamReader do odczytu pliku (537)
• Dane mogą przechodzić przez więcej niż jeden strumień (538)
• Używanie statycznych klas File i Directory do pracy z plikami i katalogami (542)
• IDisposable gwarantuje, że obiekty zostaną poprawnie zamknięte (545)
• Użyj klasy MemoryStream do strumieniowania danych do pamięci (547)
• Co dzieje się z obiektem w czasie serializacji? (553)
• Czym dokładnie JEST stan obiektu? Co trzeba zapisać? (554)
• Użyj klasy JsonSerialization do serializacji obiektów (556)
• Format JSON obejmuje tylko dane, a nie specyficzne typy języka C# (559)
• Następny krok – zanurzenie się w dane (561)
• Łańcuchy znaków w C# są kodowane w formacie Unicode (563)
• Visual Studio bardzo dobrze współdziała z Unicode (565)
• Platforma .NET używa formatu Unicode do przechowywania znaków i tekstu (566)
• C# może wykorzystać tablice bajtów do przenoszenia danych (568)
• Użyj klasy BinaryWriter do zapisu danych binarnych (569)
• Użyj klasy BinaryReader do wczytania danych (570)
• Przeglądarka danych szesnastkowych pozwala zobaczyć bajty z pliku (572)
• Użyj metody Stream.Read do wczytania bajtów ze strumienia (574)
• Zmodyfikuj przeglądarkę danych szesnastkowych, aby używała argumentów z wiersza poleceń (575)
• Ćwiczenie do pobrania – zabawa w chowanego (576)

ĆWICZENIA z Unity nr 5. Ray casting

• Utwórz nowy projekt w Unity i zacznij przygotowywać scenę (578)
• Przygotuj kamerę (579)
• Utwórz obiekt gry reprezentujący gracza (580)
• Wprowadzenie do systemu nawigowania w Unity (581)
• Przygotowanie siatki nawigacyjnej (582)
• Spraw, aby postać automatycznie poruszała się po obszarze gry (583)

11. KAPITAN WSPANIAŁY. ŚMIERĆ OBIEKTU

• Życie i śmierć obiektu (590)
• Używaj (ostrożnie) klasy GC do wymuszania odśmiecania pamięci (591)
• Finalizator obiektu – Twoja ostatnia szansa, by coś ZROBIĆ (592)
• Kiedy DOKŁADNIE uruchamiany jest finalizator? (593)
• Finalizatory nie mogą zależeć od innych obiektów (595)
• Struktura wygląda jak obiekt… (599)
• Wartości są kopiowane; referencje są przypisywane (600)
• Struktury są typami bezpośrednimi; klasy są typami referencyjnymi (601)
• Stos a sterta – więcej o pamięci (603)
• Używaj parametrów out, aby zwrócić z metody więcej niż jedną wartość (606)
• Przekazywanie przez referencję z użyciem modyfikatora ref (607)
• Używaj parametrów opcjonalnych do podawania wartości domyślnych (608)
• Referencja null nie wskazuje żadnego obiektu (609)
• Typy referencyjne niedopuszczające null pomagają unikać wyjątków NRE (610)
• Operator ?? pomaga radzić sobie z null (611)
• Typy bezpośrednie dopuszczające null mogą równać się null i być bezpiecznie obsługiwane (612)
• Kapitan Wspaniały – ale nie do końca (613)
• Metody rozszerzające dodają nowe operacje do ISTNIEJĄCYCH klas (617)
• Rozszerzanie typu podstawowego – string (619)

ROZDZIAŁ 12. Obsługa wyjątków. Gaszenie pożarów staje się nudne

• Przeglądarka danych szesnastkowych wczytuje nazwę pliku z wiersza poleceń (624)
• Gdy program zgłasza wyjątek, CLR generuje obiekt wyjątku (628)
• Wszystkie obiekty wyjątków dziedziczą po klasie System.Exception (629)
• Istnieją pliki, które nie umożliwiają wykonania zrzutu szesnastkowego (632)
• Co się dzieje, gdy wywoływana metoda jest ryzykowna? (633)
• Obsługa wyjątków za pomocą bloków try-catch (634)
• Użyj debugera do prześledzenia przepływu sterowania w bloku try-catch (635)
• Jeśli masz kod, który trzeba ZAWSZE uruchamiać, użyj bloku finally (636)
• Ogólny blok catch obsługuje wyjątki typu System.Exception (637)
• Używaj wyjątku odpowiedniego do sytuacji (642)
• Filtry wyjątków pomagają tworzyć precyzyjne bloki do ich obsługi (646)
• Najgorszy blok catch W HISTORII – ogólny blok catch z komentarzami (648)
• Tymczasowe rozwiązania są akceptowalne (tymczasowo) (649)

ĆWICZENIA z Unity nr 6. Nawigowanie po scenie

• Zacznijmy od miejsca, w którym zakończyliśmy poprzednie ćwiczenia z Unity (652)
• Dodaj platformę do sceny (653)
• Użyj opcji wstępnego obliczania, aby umożliwić chodzenie po platformie (654)
• Dodaj schody i rampę do siatki nawigacyjnej (655)
• Rozwiąż problem z wysokością w siatce nawigacyjnej (657)
• Dodaj komponent NavMesh Obstacle (658)
• Dodaj skrypt do przesuwania przeszkody w górę i w dół (659)
• Wykaż się kreatywnością! (660)

DODATEK A. Projekty ASP.NET Core Blazor. Przewodnik ucznia po Visual Studio for Mac

• Dlaczego powinieneś opanować C#? (664)
• Utwórz pierwszy projekt w Visual Studio (666)
• Napiszmy grę! (670)
• Utwórz projekt WebAssembly platformy Blazor w Visual Studio (672)
• Uruchom aplikację sieciową Blazor w przeglądarce (674)
• Teraz jesteś gotowy, by zacząć pisać kod aplikacji (676)
• Dokończ tworzenie listy emoji i wyświetl ją w aplikacji (680)
• Rozmieść zwierzęta w losowej kolejności (682)
• Uruchamianie gry w debugerze (684)
• Dodaj nowy projekt do systemu kontroli wersji (688)
• Dodaj kod C# do obsługi kliknięć myszą (689)
• Dodaj procedury obsługi kliknięć do przycisków (690)
• Przetestuj kod obsługi zdarzeń (692)
• Użyj debugera do rozwiązania problemu (693)
• Namierz błąd, który powoduje problem (696)
• Dodaj kod do resetowania gry po jej ukończeniu (698)
• Dodaj zegar do kodu gry (702)
• Uporządkuj menu nawigacyjne (704)
• Kontrolki wpływają na mechanikę interfejsów użytkownika (706)
• Utwórz nowy projekt WebAssembly platformy Blazor (707)
• Utwórz stronę z suwakiem (708)
• Dodaj do aplikacji pole na dane tekstowe (710)
• Dodaj do aplikacji okna wyboru koloru i daty (713)
• Następne zadanie – zbuduj bazującą na platformie Blazor wersję aplikacji do wybierania kart (714)
• Układ strony jest określany za pomocą wierszy i kolumn (716)
• Wiązanie danych umożliwia modyfikowanie zmiennej za pomocą suwaka (717)
• Witaj w Budżetowych Kanapkach Jarka Niechluja! (720)

DODATEK B. Kata z programowania. Podręcznik dla zaawansowanych i/lub niecierpliwych

• Skorowidz (729)