Zaawansowane wyszukiwanie
  Strona Główna » Sklep » Programowanie gier » Gry programowanie » Moje Konto  |  Zawartość Koszyka  |  Do Kasy   
 Wybierz kategorię
Algorytmy Wzorce UML
Bazy danych
Bezpieczeństwo
Bioinformatyka
Biznes Ekonomia Firma
Chemia
DTP Design
E-biznes
Ekonometria
Elektronika Elektrotechnika
Energetyka
Fizyka
GIS
Grafika użytkowa
Hardware
Informatyczne systemy zarządzania
Informatyka w szkole
Internet
Języki programowania
Matematyka
Multimedia
Obsługa komputera
Office
Poradniki
Programowanie gier
  Blender
  Grafika komputerowa
  Gry programowanie
  OpenGL
Programy inżynierskie
Programy matematyczne
Serwery
Sieci Firewalle Protokoły
Słowniki
Systemy operacyjne
Technika
Telekomunikacja
Tworzenie stron WWW

Zobacz pełny katalog »
 Wydawnictwo:
 Wolters Kluwer
Blitzmarketing Praktyczny przewodnik po narzędziach WEB 3.0

Blitzmarketing Praktyczny przewodnik po narzędziach WEB 3.0

49.00zł
41.65zł
Microsoft XNA Game Studio 4.0 Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i w 89.00zł 24.03zł
Microsoft XNA Game Studio 4.0 Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i w

Tytuł: Microsoft XNA Game Studio 4.0 Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i w
Autor: Rob Miles
ISBN: 978-83-246-3410-1
Ilość stron: 528
Data wydania: 04/2012
Oprawa: Miękka
Format: 170x230
Wydawnictwo: HELION
Cena: 89.00zł 24.03zł


"Microsoft XNA Game Studio 4.0. Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i własnego PC"

Każdy pasjonat gier komputerowych zadawał sobie czasem pytania typu: "Niesamowite, jak oni to zrobili?" albo "Jak można uzyskać taki efekt?". A co się dzieje, jeśli to pytanie przychodzi do głowy programiście? Jego następną myślą zwykle jest: "Muszę spróbować sam to zrobić!". Na co czekasz? Dziś już nic nie stoi na przeszkodzie! Odkąd Microsoft udostępnił framework XNA, każdy może wymyślić i stworzyć swoją własną profesjonalną grę komputerową, uruchomić ją na prawdziwej konsoli, a nawet wprowadzić na rynek dzięki usłudze Xbox Live lub Windows Phone Marketplace.

Jeśli zawsze marzyłeś o profesjonalnym programowaniu gier, ale nie do końca wiedziałeś, jak się za to zabrać, oto książka, która wszystko zmieni! Ten podręcznik będzie dla Ciebie doskonałym przewodnikiem, prowadzącym od opanowania podstaw frameworku XNA, przez zasady programowania w użytecznym języku C#, aż po tworzenie własnych gier.

Przejdziesz niezwykłą drogę: na jej początku czeka Cię instalacja i przygotowanie środowiska programistycznego, potem projektowanie realistycznej grafiki gry i jej ciekawe udźwiękowienie, a uwieńczeniem Twoich działań będzie stworzenie profesjonalnych projektów dla konsoli Xbox 360®, telefonów z systemem Windows® Phone 7 czy komputerów PC. Co ważne, nie musisz być zaawansowanym i doświadczonym programistą. Wszystko, czego będziesz potrzebował do realizacji tej misji, znajdziesz w tej książce!

Nauczysz się m.in.:

  • pisać kod tworzący zachowania w grze i sterujący nimi
  • projektować wygląd gry - grafikę, czcionki, kolory, oświetlenie i efekty trójwymiarowe
  • budować obiekty gry, tzw. sprajty
  • nagrywać i odtwarzać dźwięki
  • przetwarzać dane wejściowe uzyskiwane z padów i klawiatur
  • korzystać z ekranu dotykowego i akcelerometru w systemie Windows Phone
  • dodawać stopery, systemy punktacji, elementy zagrażające graczowi i postęp w rozgrywce
  • tworzyć gry wieloosobowe i sieciowe

Opanuj sztukę programowania gier i zmieniaj własne pomysły w ekscytującą rzeczywistość.

Rozdziały:

Część I: Wprowadzenie
1. Komputery, C#, XNA i Ty (19)

  • Wprowadzenie (19)
    • Nauka programowania (19)
    • Jak zostać świetnym programistą (20)
  • Jak działa ta książka (21)
  • Język C# i framework XNA (21)
  • Do dzieła (22)
    • Instalacja środowiska programowania i frameworku XNA (22)
    • Konfiguracja komputera PC pod kątem uruchamiania gier XNA (23)
    • Konfiguracja konsoli Xbox 360 pod kątem uruchamiania gier XNA (24)
    • Konfiguracja systemu Windows Phone pod kątem uruchamiania gier XNA (26)
  • Pisanie pierwszego programu (28)
    • Tworzenie pierwszego projektu (28)
    • Uruchamianie pierwszego programu (31)
    • Zatrzymywanie programu (33)
    • Przechowywanie gier w konsoli Xbox 360 lub urządzeniu z systemem Windows Phone (34)
    • Uruchamianie tej samej gry XNA na różnych urządzeniach (34)
  • Podsumowanie (37)
  • Przegląd rozdziału w pytaniach (37)

2. Programy, dane i ładne kolory (39)

  • Wprowadzenie (39)
  • Tworzenie programu gry (40)
    • Wyrażenia w metodzie Draw (41)
  • Praca z kolorami (43)
    • Przechowywanie wartości kolorów (43)
    • Ustawianie wartości koloru (44)
  • Kontrolowanie koloru (45)
    • Gry i klasy (46)
    • Klasy jako biura (48)
    • Dane świata gry (49)
    • Przechowywanie danych w pamięci komputera (51)
    • Rysowanie z wykorzystaniem zmiennych intensywności barw (52)
    • Aktualizowanie kolorów (53)
    • Przepełnienie pamięci i wartości danych (55)
    • Pełnowartościowa wielokolorowa lampa (56)
    • Podejmowanie decyzji w programie (57)
    • Gotowa gra w wielokolorową lampę (61)
    • Znajdowanie błędów w programie (63)
  • Podsumowanie (65)
  • Przegląd rozdziału w pytaniach (65)

3. Pobieranie danych wejściowych od gracza (67)

  • Wprowadzenie (67)
  • Odczytywanie stanu pada (68)
    • Pady i klasy (68)
    • Znajdowanie pada (70)
    • Testowanie statusu pada (72)
  • Stosowanie klawiatury (73)
    • Zatrzymywanie gry za pomocą klawisza Escape (75)
    • Jednoczesne używanie pada i klawiatury (75)
  • Dodawanie wibracji (77)
    • Sterowanie wibracjami pada (77)
    • Testowanie wartości intensywności (78)
  • Błędy w programie (83)
  • Podsumowanie (85)
  • Przegląd rozdziału w pytaniach (85)

Część II: Obrazy, dźwięk i tekst
4. Wyświetlanie obrazów (89)

  • Wprowadzenie (89)
  • Zasoby i zawartość (90)
    • Dodawanie obrazów (90)
    • Zarządzanie zawartością z użyciem XNA (92)
    • Praca z zawartością za pomocą XNA Game Studio (92)
    • Rozwiązania i projekty w XNA Game Studio (92)
    • Dodawanie zawartości do projektu (94)
  • Korzystanie z zasobów w programie gry (97)
    • Ładowanie tekstur w XNA (97)
    • Pozycjonowanie sprajtu na ekranie (101)
    • Wyświetlanie sprajtu za pomocą klasy SpriteBatch (103)
    • Wypełnianie ekranu (105)
    • Intellisense (106)
  • Podsumowanie (108)
  • Przegląd rozdziału w pytaniach (108)

5. Wyświetlanie tekstu (111)

  • Wprowadzenie (111)
  • Komputery i tekst (111)
    • Tekst jako zasób (112)
    • Tworzenie projektu zegara w XNA (112)
    • Dodawanie czcionki do zasobów (112)
    • Format plików XML (115)
    • Ładowanie czcionki (115)
    • Wyświetlanie z użyciem czcionki (116)
    • Zmiana właściwości czcionki (118)
  • Uzyskiwanie daty i czasu (119)
  • Tworzenie ładniejszego zegara z tekstem 3D (122)
    • Wielokrotne wyświetlanie łańcuchów tekstu (122)
    • Powtarzanie instrukcji z użyciem pętli for (124)
    • Inne konstrukcje pętli (126)
    • Zabawa z pętlą for (126)
  • Tworzenie iluzji trójwymiaru (128)
    • Tworzenie cieni z użyciem kolorów przezroczystych (128)
    • Wyświetlanie obrazów z użyciem przezroczystości (130)
  • Podsumowanie (131)
  • Przegląd rozdziału w pytaniach (131)

6. Tworzenie gry dla wielu graczy (133)

  • Wprowadzenie (133)
    • Tworzenie gry z wciskaniem przycisków (133)
    • Dane w grze ButtonBash (134)
    • Rozpoczynanie gry ButtonBash (134)
    • Wyświetlanie wartości licznika wciśnięć przycisku (135)
    • Zliczanie wciśnięć przycisku (135)
    • Wykrywanie zmian położenia przycisku (136)
    • Wykrywanie poziomu i zbocza (137)
    • Konstruowanie kompletnej gry (138)
    • Projektowanie kodu (140)
    • Dodawanie kodu testowego (140)
  • Podsumowanie (143)
  • Przegląd rozdziału w pytaniach (143)

7. Odtwarzanie dźwięków (145)

  • Dodawanie dźwięku (145)
    • Tworzenie projektu Drum Pad (145)
    • Nagrywanie dźwięków w programie Audacity (146)
    • Przechowywanie dźwięków w projekcie (147)
    • Stosowanie dźwięków w programie w XNA (149)
    • Odtwarzanie muzyki w tle (151)
    • Ciągłe odtwarzanie dźwięku (151)
    • Kontrola wartości null w referencjach (155)
    • XACT audio tool (156)
    • Odtwarzanie muzyki za pomocą klasy MediaPlayer (156)
  • Podsumowanie (158)
  • Przegląd rozdziału w pytaniach (158)

8. Pomiar czasu (159)

  • Tworzenie kolejnej gry (159)
    • Błąd w pomiarze czasu reakcji (162)
  • Ustalanie zwycięzcy za pomocą tablic (164)
    • Tworzenie tablicy (165)
    • Korzystanie z danych w tablicy (165)
    • Przeglądanie tablicy (167)
    • Zastosowanie tablicy jako słownika (168)
    • Wyświetlanie zwycięzcy (170)
  • Podsumowanie (172)
  • Przegląd rozdziału w pytaniach (172)

9. Wczytywanie tekstu wejściowego (173)

  • Używanie klawiatury w XNA (173)
    • Tworzenie projektu Tablica ogłoszeń (173)
    • Rejestrowanie wciśnięć klawiszy (174)
    • Wykrywanie momentu wciśnięcia klawisza (175)
    • Typ Keys (175)
    • Typy wyliczeniowe (176)
  • Praca z tablicami, obiektami i referencjami (177)
    • Wartości i referencje (177)
    • Tablice jako biura (178)
    • Przywitaj się z procesem odzyskiwania pamięci (179)
    • Używanie referencji i wartości (180)
    • Do czego służą referencje i wartości? (181)
    • Referencje i metoda GetPressedKeys (182)
  • Wyświetlanie klawiszy (182)
    • Wykrywanie wciśnięć klawiszy (183)
    • Dekodowanie znaków na klawiszach (188)
    • Używanie klawiszy Shift (189)
    • A co z polskimi znakami? (190)
    • Edycja tekstu (192)
  • Podsumowanie (193)
  • Przegląd rozdziału w pytaniach (194)

Część III: Pisanie poprawnych gier
10. Używanie metod języka C# do rozwiązywania problemów (197)

  • Wprowadzenie (197)
  • Zabawa z obrazami (197)
    • Przybliżanie obrazu (198)
  • Tworzenie efektu oddalania (200)
    • Aktualizowanie prostokąta rysowania (200)
    • Tworzenie metody obliczającej wartości procentowe (203)
    • Stosowanie słowa void (206)
    • Diagnozowanie programów języka C# (210)
    • Trafianie w punkt zatrzymania (212)
    • Używanie liczb zmiennoprzecinkowych w języku C# (214)
    • Kompilator i typy danych języka C# (215)
    • Kompilatory i rzutowanie (217)
    • Typy wyrażeń (218)
    • Zatrzymywanie oddalania (220)
    • Oddalanie ze środka zdjęcia (220)
  • Podsumowanie (224)
  • Przegląd rozdziału w pytaniach (224)

11. Gra jako program języka C# (227)

  • Wprowadzenie (227)
  • Tworzenie grafiki gry (228)
  • Projekty, zasoby i klasy (229)
    • Rozwiązania i projekty środowiska XNA Game Studio (229)
    • Plik Program.cs (232)
    • Zmiana nazwy klasy Game1 (238)
  • Tworzenie obiektów gry (240)
    • Sprajty w grze (240)
    • Zarządzanie rozmiarem sprajtów gry (240)
    • Wprawianie sprajtów w ruch (244)
    • Odbijanie sera (246)
    • Obsługa nadmiarowości ekranu (246)
  • Podsumowanie (248)
  • Przegląd rozdziału w pytaniach (249)

12. Gry, obiekty i stan (251)

  • Wprowadzenie (251)
  • Dodanie chleba do gry (251)
    • Stosowanie struktury do przechowywania informacji o sprajcie (252)
    • Sterowanie ruchem za pomocą gałki pada (254)
    • Doskonalenie programów za pomocą metod (256)
    • Obsługa kolizji (259)
    • Odbijanie sera od chleba (260)
    • Dziwne zachowanie mechanizmu odbijania (260)
    • Dziwne zachowanie krawędzi (261)
  • Dodanie pomidorowych celów (264)
    • Kolizje z pomidorami (267)
  • Podsumowanie (269)
  • Przegląd rozdziału w pytaniach (270)

13. Tworzenie kompletnej gry (271)

  • Wprowadzenie (271)
  • Tworzenie skończonej gry (271)
    • Dodanie punktacji do gry (271)
    • Dodanie elementu ryzyka (273)
    • Dodanie postępu w grze (275)
  • Doskonalenie projektu kodu (278)
    • Refaktoryzacja poprzez tworzenie metod dla istniejącego kodu (279)
    • Refaktoryzacja poprzez zmianę identyfikatorów (280)
    • Tworzenie obszarów kodu (282)
    • Tworzenie przydatnych komentarzy (283)
  • Dodanie tła (285)
  • Dodanie ekranu tytułowego (286)
    • Gry i stan (287)
    • Stosowanie wartości stanu (287)
    • Budowa maszyny stanów (288)
  • Podsumowanie (291)
  • Przegląd rozdziału w pytaniach (291)

14. Klasy, obiekty i gry (293)

  • Wprowadzenie (293)
  • Projektowanie przy użyciu obiektów (293)
    • Kurs odświeżający wiedzę o obiektach (294)
    • Spójność i obiekty (295)
    • Związki pomiędzy obiektami (298)
    • Projektowanie interakcji pomiędzy obiektami (301)
    • Obiekty kontenerów (303)
    • Obiekty tła i ekranu tytułowego (305)
  • Klasy i struktury (306)
    • Tworzenie i stosowanie struktury (306)
    • Tworzenie i stosowanie egzemplarza klasy (307)
  • Referencje (309)
    • Wiele referencji do jednego egzemplarza (309)
    • Brak referencji do egzemplarza (310)
    • Po co w ogóle stosować referencje? (311)
  • Typy wartościowe i referencyjne (311)
    • Czy obiekty w naszej grze powinny mieć postać klas, czy też struktur? (312)
  • Tworzenie hierarchii klas sprajtów (314)
    • Klasa BaseSprite (314)
    • Rozszerzenie klasy BaseSprite w celu utworzenia klasy TitleSprite (316)
    • Budowa hierarchii klas (317)
  • Dodanie morderczej papryki (318)
    • Tworzenie klasy DeadlySprite (318)
  • Podsumowanie (323)
  • Przegląd rozdziału w pytaniach (323)

15. Tworzenie komponentów gry (325)

  • Wprowadzenie (325)
  • Obiekty i abstrakcja (325)
    • Tworzenie klasy abstrakcyjnej w języku C# (326)
    • Rozszerzanie klasy abstrakcyjnej (327)
    • Projektowanie przy użyciu klas abstrakcyjnych (328)
    • Referencje do abstrakcyjnych klas macierzystych (329)
  • Konstruowanie egzemplarzy klas (330)
    • Konstruktory w strukturach (332)
    • Konstruktory w hierarchii klas (333)
  • Dodanie stu zabójczych mandarynek (335)
    • Tworzenie klasy KillerSprite (335)
    • Ustawianie położenia sprajtów KillerSprite za pomocą liczb losowych (336)
    • Stosowanie list referencji (339)
  • Dodanie sztucznej inteligencji (342)
    • Ściganie pałki chlebowej (343)
  • Dodanie dźwięków w grze (347)
  • Od obiektów do komponentów (350)
    • Interfejsy języka C# (351)
    • Tworzenie interfejsu (352)
    • Implementowanie interfejsu (353)
    • Referencje do interfejsów (353)
    • Łączenie chleba, sera i pomidorów (354)
    • Projektowanie przy użyciu interfejsów (354)
  • Podsumowanie (355)
  • Przegląd rozdziału w pytaniach (355)

16. Tworzenie gier sieciowych dla wielu graczy (357)

  • Wprowadzenie (357)
  • Sieci i komputery (357)
    • Wszystko zaczyna się od sygnału (358)
    • Konstruowanie pakietów (358)
    • Adresowanie komunikatów (358)
    • Trasowanie (359)
    • Połączenia i datagramy (360)
    • Sieci i protokoły (361)
  • Usługa Xbox Live (362)
    • Karty graczy i usługa Xbox Live (362)
    • Technologia System Link i framework XNA (363)
  • Ping-pong chleba i sera (363)
    • Zarządzanie profilami graczy we frameworku XNA (364)
    • Sprawdzanie logowania gracza na potrzeby gry sieciowej (368)
    • Tworzenie lobby gry (369)
    • Gry sieciowe i stan (369)
    • Rozgrywka (377)
    • Kompletna gra (382)
  • Podsumowanie (382)
  • Przegląd rozdziału w pytaniach (383)

Część IV: Tworzenie mobilnych gier dla systemu Windows Phone 7 za pomocą XNA (385)
17. Gry sterowane ruchem telefonu (387)

  • Wprowadzenie (387)
  • Akcelerometr (387)
    • Do czego tak naprawdę służy akcelerometr? (387)
  • Przyspieszenie z punktu widzenia fizyki (388)
    • Interpretowanie odczytów z akcelerometru (390)
  • Tworzenie gry Cheese Lander sterowanej przechylaniem (391)
    • Obiekty świata gry Cheese Lander (391)
    • Dostęp do klasy Accelerometer z programu w XNA (392)
    • Używanie klasy Accelerometer w grze dla środowiska XNA (395)
    • Uruchamianie akcelerometru (397)
    • Wykorzystanie odczytów z akcelerometru w programie gry (398)
    • Poprawianie przebiegu gry z wykorzystaniem praw fizyki (398)
    • Wyrażanie ruchu za pomocą wektorów (400)
    • Dodawanie tarcia (401)
    • Sterowanie dźwiękiem za pomocą wektorów (402)
    • Wykrywanie potrząsania (403)
    • Krótka dygresja na temat wątków i synchronizacji (403)
  • Podsumowanie (405)
  • Przegląd rozdziału w pytaniach (406)

18. Obsługa sterowania dotykiem (407)

  • Wprowadzenie (407)
  • Ekran dotykowy w telefonach z systemem Windows Phone (407)
    • Pobieranie wejścia dotykowego (408)
  • Tworzenie przycisku alarmowego (408)
    • Odczytywanie zdarzeń z wejścia dotykowego (409)
    • Typy obiektów TouchLocation (409)
    • Obsługa miejsca dotknięcia (411)
  • Tworzenie dotykowej perkusji (412)
    • Tworzenie klasy SoundPad dla każdego z dźwięków perkusji (412)
    • Przechowywanie w programie wartości typu soundPad (413)
    • Wyświetlanie przycisków (414)
    • Odświeżanie stanu przycisków (415)
    • Podświetlanie przycisków (416)
  • Tworzenie "ślizganej" gry planszowej (418)
    • Klasa PuckSprite (419)
    • Odświeżanie stanu nieruchomego krążka (420)
    • Przemieszczanie krążka po ekranie (421)
    • Krążek poruszający się po planszy (422)
    • Emulatory i prawdziwe urządzenia (424)
  • Podsumowanie (425)
  • Przegląd rozdziału w pytaniach (425)

19. Konstruowanie mobilnych gier (427)

  • Wprowadzenie (427)
  • Telefon z systemem Windows Phone (427)
    • Windows Phone Marketplace (428)
  • Wydłużanie czasu życia baterii telefonu podczas działania gier w XNA (428)
    • Ustawianie częstotliwości odświeżania w grze (428)
  • Obsługa zmian orientacji telefonu (429)
    • Wybór orientacji z programu gry w XNA (430)
    • Otrzymywanie komunikatu o zmianie orientacji (430)
  • Używanie określonego rozmiaru ekranu w grach dla systemu Windows Phone (432)
  • Ukrywanie paska stanu systemu Windows Phone (432)
  • Wyłączanie blokowania ekranu podczas gry (433)
  • Tworzenie maszyny stanów dla telefonu (434)
    • Gry i stany (434)
    • Tworzenie prostej maszyny stanów dla gry (435)
    • Tworzenie bardziej skomplikowanych maszyn stanów (437)
  • Obsługa przychodzących połączeń telefonicznych (439)
    • Wykrywanie połączeń telefonicznych (441)
  • Gra jako aplikacja w systemie Windows Phone (442)
    • Przyciski Back i Start systemu Windows Phone (443)
    • Uruchamianie nowych programów za pomocą przycisku Start (445)
    • Korzystanie z izolowanych obszarów przechowywania do zapisywania stanu gry (446)
  • Dostarczanie naszych gier do usługi Marketplace (453)
    • Usługa Windows Phone Marketplace (453)
    • Rejestracja w serwisie App Hub (454)
    • Używane urządzenia z systemem Windows Phone (454)
    • Tworzenie gier na sprzedaż (454)
  • Podsumowanie (455)
  • Przegląd rozdziału w pytaniach (455)
Microsoft XNA Game Studio 4.0 Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i w
Tytuł książki: "Microsoft XNA Game Studio 4.0 Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i w"
Autor: Rob Miles
Wydawnictwo: HELION
Cena: 89.00zł 24.03zł
Klienci, którzy kupili „Microsoft XNA Game Studio 4.0 Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i w”, kupili także:
<b>Praktyka przetwarzania obrazów z zadaniami w programie Matlab</b>, <font color="navy">Zygmunt Wróbel, Robert Koprowski</font>, <font color="green"> Wydawnictwo EXIT</font>
Praktyka przetwarzania obrazów z zadaniami w programie Matlab, Zygmunt Wróbel, Robert Koprowski, Wydawnictwo EXIT
<b>Roboty przemysłowe Budowa i zastosowanie Wydanie 2</b>, <font color="navy">Jerzy Honczarenko</font>, <font color="green"> Wydawnictwo WNT</font>
Roboty przemysłowe Budowa i zastosowanie Wydanie 2, Jerzy Honczarenko, Wydawnictwo WNT
<b>Komputerowa wizja Metody interpretacji i identyfikacji obiektów</b>, <font color="navy">Ryszard S. Choraś</font>, <font color="green"> Wydawnictwo EXIT</font>
Komputerowa wizja Metody interpretacji i identyfikacji obiektów, Ryszard S. Choraś, Wydawnictwo EXIT
<b>Visual Studio 2013 Podręcznik programowania w C# z zadaniami</b>, <font color="navy">Jacek Matulewski</font>, <font color="green"> Wydawnictwo HELION</font>
Visual Studio 2013 Podręcznik programowania w C# z zadaniami, Jacek Matulewski, Wydawnictwo HELION
<b>RTLinux System czasu rzeczywistego</b>, <font color="navy">Kazimierz Lal, Tomasz Rak, Krzysztof Orkisz</font>, <font color="green"> Wydawnictwo HELION</font>
RTLinux System czasu rzeczywistego, Kazimierz Lal, Tomasz Rak, Krzysztof Orkisz, Wydawnictwo HELION
<b>Wyrażenia regularne Receptury</b>, <font color="navy">Jan Goyvaerts, Steven Levithan</font>, <font color="green"> Wydawnictwo HELION</font>
Wyrażenia regularne Receptury, Jan Goyvaerts, Steven Levithan, Wydawnictwo HELION
 Koszyk
0 przedmiotów
Producent
Tu można zobaczyć wszystkie książki z wydawnictwa:

Wydawnictwo HELION
 Kategoria:
 Układy cyfrowe
PicoBlaze Mikroprocesor w FPGA

PicoBlaze Mikroprocesor w FPGA

82.00zł
65.60zł
Informacje
Regulamin sklepu.
Koszty wysyłki.
Polityka prywatności.
Jak kupować?
Napisz do Nas.
 Wydawnictwa
 Poradniki
Egzamin 70-412: Konfigurowanie zaawansowanych usług Windows Server 2012 R2 J. C. Mackin, Orin Thomas Microsoft Press
Jak zdać egzamin zawodowy w technikum informatycznym? Kwalifikacje E.12, E.13, E.14 Tomasz Kowalski HELION
Android Programowanie aplikacji Rusz głową Dawn Griffiths, David Griffiths HELION
Prolog Programowanie W.F. Clocksin, C.S. Mellish HELION
Układy mikroprocesorowe przykłady rozwiązań Bartłomiej Zieliński HELION
Serwer SQL 2008 Administracja i programowanie Danuta Mendrala, Paweł Potasiński, Marcin Szeliga, Damian Widera HELION
AVR Praktyczne projekty Tomasz Francuz HELION
Podstawy fizyki powierzchni półprzewodników Anna Szaynok, Stanisław Kuźmiński WNT
Windows Server 2008 PL Biblia Jeffrey R. Shapiro HELION

wtorek, 11 grudzień 2018   Mapa strony |  Nowości |  Dzisiejsze promocje |  Koszty wysyłki |  Kontakt z nami