Wprowadzenie do fizyki w grach, animacjach i symulacjach Flash [PDF]

Zitiervorschau

Tytuł oryginału: The Essential Guide to Physics for Flash Games, Animation, and Simulations Tłumaczenie: Julia Szajkowska ISBN: 978-83-246-7184-7 Original edition copyright © 2011 by Dev Ramtal and Adrian Dobre All rights reserved. Polish edition copyright © 2013 by HELION SA. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Wydawnictwo HELION dołożyło wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: [email protected] WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/wprofi.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/wprofi_ebook Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland.

• Poleć książkę na Facebook.com

• Księgarnia internetowa

• Kup w wersji papierowej

• Lubię to! » Nasza społeczność

• Oceń książkę

Mojej mamie, dzięki której stałem się możliwy; mojej żonie i córce, dzięki wsparciu których ta książka stała się możliwa. - DR

Mojej rodzinie, tak wyrozumiałej, kiedy byłem daleko od domu pracując nad tą książką. - AD

Spis treści O autorach . .................................................................................................................17 O recenzencie technicznym książki ..........................................................................17 O twórcy grafiki na okładce książki ..........................................................................18 Podziękowania . ..........................................................................................................18 Przedmowa . ................................................................................................................19 Część I. Podstawy . ......................................................................................................23 Rozdział 1. Wprowadzenie do oprogramowywania zjawisk fizycznych ................25 Po co modeluje się zjawiska fizyczne? .....................................................................................................25 Uzyskanie realistycznie wyglądających efektów . ................................................................................26 Tworzenie realistycznie wyglądających gier . ........................................................................................26 Tworzenie symulacji i modeli . ....................................................................................................................26 Tworzenie dzieł sztuki ...................................................................................................................................27 Czy nie wystarczy użyć biblioteki fizycznej? . ........................................................................................27 Czym jest fizyka? . ............................................................................................................................................28 Wszystko wokół nas podlega prawom fizyki . .......................................................................................29 Prawa i zasady fizyki można zapisać za pomocą równań matematycznych ..............................29 Opisywanie ruchu ciała .................................................................................................................................29 Oprogramowywanie zjawisk fizycznych .................................................................................................30 Na czym polega różnica między animacją a symulacją? . .................................................................30 Prawa fizyki są proste .....................................................................................................................................31 Dlatego można w prosty sposób zapisać je w postaci kodu! . ........................................................31 Cztery kroki oprogramowywania fizyki . .................................................................................................31 Prosty przykład . ...............................................................................................................................................32 Odbijająca się piłka — opis fizyczny . .......................................................................................................32 Opisanie kodem ruchu piłki w dwóch wymiarach . .............................................................................33 Podsumowanie . ...............................................................................................................................................35

Rozdział 2. Programowanie w języku ActionScript 3.0 — wybrane zagadnienia .......................................................................37 Klasy w języku ActionScript 3.0 ..................................................................................................................38 Klasy i obiekty . ...........................................................................................................................................39 Budowa klasy w AS3.0 . ...........................................................................................................................39 Funkcje, metody i konstruktory ...........................................................................................................40 Właściwości . ...............................................................................................................................................40 5

Spis treści

Statyczne metody i statyczne właściwości . ...........................................................................................41 Dziedziczenie ....................................................................................................................................................41 Podstawy programowania w języku skryptowym ActionScript 3.0 .............................................42 Zmienne i stałe .................................................................................................................................................42 Typy danych ......................................................................................................................................................43 Operatory ...........................................................................................................................................................46 Klasa Math ..........................................................................................................................................................47 Logika ..................................................................................................................................................................48 Pętle .....................................................................................................................................................................49 Zdarzenia w języku ActionScript 3.0 .........................................................................................................51 Procedury wykrywające wystąpienie zdarzenia i obsługujące zdarzenie ..................................51 Zdarzenia w działaniach użytkownika . ...................................................................................................52 Przeciągnij i upuść ..........................................................................................................................................52 Układ współrzędnych we Flashu ................................................................................................................53 Współrzędne w dwóch wymiarach . .........................................................................................................53 Układ trójwymiarowy we Flashu . ..............................................................................................................54 Graficzny interfejs programowania Flasha .............................................................................................56 Rysowanie prostych i krzywych . ................................................................................................................56 Wypełnienia i gradienty ................................................................................................................................57 Przykład — piłka wewnątrz pudełka . .......................................................................................................58 Tworzenie animacji za pomocą kodu .......................................................................................................60 Wbudowane odliczanie klatek w roli zegara . .......................................................................................60 Praca z klasą Timer ..........................................................................................................................................61 Wyznaczanie upływu czasu za pomocą funkcji getTimer() . ............................................................62 Przygotowywanie danych do wykonania animacji . ...........................................................................64 Wykrywanie zderzeń . ....................................................................................................................................65 Praca z metodą hitTestObject() . ................................................................................................................65 Praca z metodą hitTestPoint() . ...................................................................................................................65 Wykrywanie zderzeń na podstawie wyznaczania odległości . ........................................................65 Złożone algorytmy wykrywania zderzeń . ..............................................................................................67 Podsumowanie . ...............................................................................................................................................67

Rozdział 3. Nieco podstaw z matematyki .................................................................69 Układ współrzędnych i proste wykresy ...................................................................................................70 Narzędzie rysujące — klasa Graph .....................................................................................................70 Tworzenie wykresów funkcji za pomocą klasy Graph .................................................................71 Proste . ...........................................................................................................................................................73 Wykresy wielomianów . ..........................................................................................................................73 Wzrost i zanik — funkcje wykładnicze i logarytmiczne ..............................................................74 Wprawianie obiektu w ruch wzdłuż krzywej ..................................................................................76 Odległość pomiędzy dwoma punktami ...........................................................................................82 6

Spis treści

Podstawy trygonometrii . .............................................................................................................................83 Stopnie i radiany ..............................................................................................................................................84 Funkcja sinus .....................................................................................................................................................84 Funkcja cosinus ................................................................................................................................................85 Funkcja tangens ...............................................................................................................................................87 Funkcje cyklometryczne ...............................................................................................................................88 Funkcje trygonometryczne w animacjach . ...........................................................................................89 Wektory i podstawy algebry wektorowej ...............................................................................................93 Czym są wektory? ............................................................................................................................................93 Wektory i skalary ..............................................................................................................................................94 Sumowanie wektorów ..................................................................................................................................94 Rozkładanie wektorów na składowe . ......................................................................................................96 Mnożenie wektorów — iloczyn skalarny . ..............................................................................................98 Mnożenie wektorów — iloczyn wektorowy . ........................................................................................99 Algebra wektorów w klasie Vector2D ...................................................................................................100 Podstawy rachunku różniczkowo-całkowego . ..................................................................................102 Kąt nachylenia, czyli gradient ...................................................................................................................102 Tempo zmian — pochodna ......................................................................................................................104 Sumowanie — całki . ....................................................................................................................................108 Podsumowanie ..............................................................................................................................................110

Rozdział 4. Podstawy fizyki .....................................................................................111 Podstawowe pojęcia z dziedziny fizyki i stosowane zapisy . .........................................................112 Wielkości fizyczne i ich jednostki ............................................................................................................112 Notacja naukowa . .........................................................................................................................................112 Cząstki i pozostałe obiekty fizyczne . ......................................................................................................113 Czym jest cząstka? . .......................................................................................................................................114 Właściwości cząstek . ...................................................................................................................................114 Tworzenie klasy Particle ..............................................................................................................................115 Przesuwanie cząstek — klasa Mover .....................................................................................................118 Rozwijanie klasy Particle .............................................................................................................................120 Opisywanie ruchu — kinematyka . .........................................................................................................124 Idee — przemieszczenie, prędkość, szybkość i przyśpieszenie ...................................................124 Dodawanie wielkości wektorowych ......................................................................................................127 Ilustrowanie ruchu na wykresach ...........................................................................................................128 Równania ruchu jednostajnie przyśpieszonego ...............................................................................128 Przykład zastosowania równań ruchu — lot pocisku ......................................................................130 Inne pojęcia związane z ruchem — bezwładność, masa i pęd ....................................................133 Przewidywanie ruchu ciała — siły i dynamika . ..................................................................................134 Siła — przyczyna ruchu ........................................................................................................................134 Zależność łącząca siłę, masę i przyśpieszenie . ............................................................................135 7

Spis treści

Rodzaje sił . ......................................................................................................................................................135 Rozkładanie sił — składanie wektorów i siła wypadkowa .............................................................136 Siły w stanie równowagi .............................................................................................................................138 Przykład — spadające ciało .......................................................................................................................139 Energia ..............................................................................................................................................................142 Pojęcie pracy w fizyce . ................................................................................................................................143 Zdolność do wykonania pracy — energia ...........................................................................................144 Przekazywanie, przekształcanie i zachowanie energii ....................................................................144 Energia potencjalna i energia kinetyczna ............................................................................................145 Moc . ...................................................................................................................................................................146 Przykład — prosta symulacja „samochodu” .......................................................................................147 Podsumowanie ..............................................................................................................................................150

Część II. Cząstki, siły i ruch .......................................................................................151 Rozdział 5. Zasady rządzące ruchem ......................................................................153 Zasady dynamiki Newtona . .......................................................................................................................154 Pierwsza zasada dynamiki Newtona (N1) ............................................................................................154 Druga zasada dynamiki Newtona (N2) ..................................................................................................155 Trzecia zasada dynamiki Newtona (N3) ................................................................................................157 Stosowanie zasad dynamiki Newtona . .................................................................................................158 Ogólna metoda pracy z równaniem F = m·a .......................................................................................158 Klasa Forcer . ...................................................................................................................................................158 Klasa Forces . ...................................................................................................................................................159 Prosty przykład — lot pocisku w powietrzu ........................................................................................160 Bardziej złożony przykład — pływająca piłka .....................................................................................162 Różniczkowa postać drugiej zasady dynamiki Newtona . ..............................................................164 Co kryje się za wzorem F = m·a? ..............................................................................................................165 Przykład — ponownie spadające ciało .................................................................................................166 Zasada zachowania energii . ......................................................................................................................167 Zasada zachowania energii mechanicznej ..........................................................................................168 Przykład — zmiany energii w czasie lotu pocisku ............................................................................168 Zasada zachowania pędu ..........................................................................................................................171 Przykład — zderzenie dwóch cząstek w jednym wymiarze . ..................................................173 Zasady obowiązujące w ruchu obrotowym . ......................................................................................175 Podsumowanie ..............................................................................................................................................175

Rozdział 6. Grawitacja, orbity i statki kosmiczne ..................................................177 Grawitacja ........................................................................................................................................................177 Grawitacja, ciężar i masa ......................................................................................................................178 Prawo powszechnego ciążenia . ........................................................................................................178 Przygotowanie funkcji gravity . ..........................................................................................................179 8

Spis treści

Orbity .................................................................................................................................................................181 Klasa Orbiter . ..................................................................................................................................................181 Prędkość ucieczki . ........................................................................................................................................185 Ruch dwóch ciał . ...........................................................................................................................................186 Grawitacja przy powierzchni Ziemi . .......................................................................................................189 Przyśpieszenie grawitacyjne w pobliżu powierzchni Ziemi ..........................................................189 Zależność przyśpieszenia ziemskiego od wysokości .......................................................................190 Przyśpieszenie grawitacyjne na innych ciałach niebieskich .........................................................191 Rakiety ...............................................................................................................................................................192 Prawdziwie odlotowa nauka! ....................................................................................................................192 Modelowanie odrzutu . ...............................................................................................................................193 Tworzenie symulacji lotu rakiety .............................................................................................................193 Podsumowanie ..............................................................................................................................................199

Rozdział 7. Siły kontaktowe i dynamika płynów ...................................................201 Siły kontaktowe .............................................................................................................................................202 Siły normalne . ................................................................................................................................................202 Naprężanie i ściskanie .................................................................................................................................203 Tarcie . ................................................................................................................................................................204 Przykład — ruch ciała po równi pochyłej .............................................................................................205 Ciśnienie ...........................................................................................................................................................211 Czym jest ciśnienie? . ...................................................................................................................................211 Gęstość . ............................................................................................................................................................212 Ciśnienie na określonej głębokości wywierane przez płyn ...........................................................213 Ciśnienie statyczne i ciśnienie dynamiczne ........................................................................................213 Wypór hydrostatyczny ................................................................................................................................214 Prawo Archimedesa ..............................................................................................................................215 Ciężar pozorny ........................................................................................................................................215 Ciała całkowicie zanurzone . ...............................................................................................................216 Ciała pływające ........................................................................................................................................216 Przykład — balon ...................................................................................................................................217 Siła oporu ..................................................................................................................................................219 Siła oporu przy małych prędkościach . ............................................................................................219 Siła oporu przy dużych prędkościach . ............................................................................................220 Której siły oporu mam używać? . .......................................................................................................221 Wprowadzenie ruchu oporu powietrza do symulacji lotu balonu . .....................................222 Przykład — piłka pływająca po powierzchni wody . ..................................................................223 Prędkość końcowa .................................................................................................................................227 Przykład — spadochron ......................................................................................................................229

9

Spis treści

Siła nośna .........................................................................................................................................................231 Współczynnik wznoszenia .........................................................................................................................232 Przykład — samolot . ...................................................................................................................................233 Wiatr i turbulencje ........................................................................................................................................235 Wiatr źródłem siły . ........................................................................................................................................235 Wiatr a opór . ...................................................................................................................................................235 Przepływ stabilny i turbulentny ...............................................................................................................236 Przykład — ruch baniek przy stałym wietrze ......................................................................................236 Modelowanie przepływu turbulentnego .............................................................................................238 Podsumowanie ..............................................................................................................................................239

Rozdział 8. Siła sprężystości — drgania sprężyny .................................................241 Sprężyny i oscylatory — podstawowe zjawiska . ...............................................................................241 Ruch drgający . ...............................................................................................................................................242 Siła sprężystości, tłumienie i wymuszanie ...........................................................................................242 Prawo Hooke’a . .............................................................................................................................................243 Drgania swobodne .......................................................................................................................................244 Funkcja wyznaczająca siłę sprężystości ................................................................................................244 Przygotowanie prostego oscylatora ......................................................................................................244 Prosty ruch harmoniczny ...........................................................................................................................246 Drgania a dokładność obliczeń numerycznych .................................................................................248 Drgania tłumione ..........................................................................................................................................252 Siła tłumiąca . ..................................................................................................................................................252 Skutek tłumienia drgań ...............................................................................................................................253 Analityczne rozwiązanie równania ruchu drgającego z tłumieniem .........................................254 Drgania wymuszone ....................................................................................................................................255 Siła wymuszająca . .........................................................................................................................................255 Przykład — okresowa siła wymuszająca ...............................................................................................256 Przykład — losowa siła wymuszająca ....................................................................................................257 Grawitacja jako siła wymuszająca — skoki na bungee ...................................................................257 Przykład — siła wymuszająca sterowana przez użytkownika . .....................................................261 Układy oscylatorów — wiele ciał na sprężynach . .............................................................................263 Przykład — łańcuch mas połączonych sprężynami . .................................................................263 Podsumowanie ..............................................................................................................................................267

Rozdział 9. Siła dośrodkowa. Ruch obrotowy ........................................................269 Kinematyka jednostajnego ruchu po okręgu . ...................................................................................269 Kąt przemieszczenia ..............................................................................................................................270 Prędkość kątowa ....................................................................................................................................271 Przyśpieszenie kątowe .........................................................................................................................271 Okres, częstotliwość i prędkość kątowa . .......................................................................................271 10

Spis treści

Zależność między prędkością kątową a liniową ................................................................................272 Przykład — toczące się koło ......................................................................................................................274 Obracające się cząstki . ................................................................................................................................276 Przykład — satelita okrążający obracającą się Ziemię ....................................................................277 Przyśpieszenie dośrodkowe i siła dośrodkowa . ................................................................................280 Przyśpieszenie dośrodkowe ......................................................................................................................280 Przyśpieszenie dośrodkowe, prędkość i prędkość kątowa ............................................................281 Siła dośrodkowa . ..........................................................................................................................................282 Często popełniane błędy ............................................................................................................................282 Przykład — kolejna próba opisania ruchu satelity ...........................................................................283 Przykład — orbity kołowe dla siły grawitacji ......................................................................................284 Przykład — samochód na zakręcie .........................................................................................................287 Niejednostajny ruch po okręgu . ..............................................................................................................290 Siła styczna i przyśpieszenie styczne .....................................................................................................291 Przykład — wahadło matematyczne .....................................................................................................291 Podsumowanie ..............................................................................................................................................295

Rozdział 10. Siły dalekozasięgowe .........................................................................297 Oddziaływanie między cząstkami a pole siły . .....................................................................................298 Oddziaływanie na odległość .....................................................................................................................298 Od oddziaływań międzycząsteczkowych do pól sił .........................................................................298 Grawitacja w ujęciu Newtona . .................................................................................................................299 Pole grawitacyjne wytwarzane przez ciało ..........................................................................................300 Wiele ciał w polu grawitacyjnym .............................................................................................................300 Pole grawitacyjne układu dwóch mas ...................................................................................................302 Trajektoria pocisku poruszającego się w polu grawitacyjnym ....................................................305 Prosta gra — uniknij czarnej dziury .......................................................................................................308 Siła elektrostatyczna ....................................................................................................................................315 Ładunek elektryczny . ..................................................................................................................................315 Prawo Coulomba oddziaływań elektrostatycznych .........................................................................316 Przyciąganie i odpychanie między naładowanymi cząstkami .....................................................317 Pole elektrostatyczne . .................................................................................................................................319 Siła elektromagnetyczna . ...........................................................................................................................322 Pole magnetyczne i działające w nim siły ............................................................................................322 Siła Lorentza . ..................................................................................................................................................323 Siły innych rodzajów ....................................................................................................................................325 Siły centralne . .................................................................................................................................................326 Grawitacja sprężysta? ..................................................................................................................................329 Grawitacja w polu wielu źródeł generujących różne pola .............................................................331 Podsumowanie ..............................................................................................................................................333

11

Spis treści

Część III. Układy wielu cząstek i układy wielopokoleniowe ..................................335 Rozdział 11. Zderzenia .............................................................................................337 Modelowanie zderzeń ................................................................................................................................338 Odbicie od poziomej lub pionowej ściany . .........................................................................................338 Odbicie sprężyste . ........................................................................................................................................339 Rozpraszanie energii na zderzenie .........................................................................................................342 Odbicie od ukośnej ściany . ........................................................................................................................343 Wykrywanie zderzeń . ..................................................................................................................................343 Przesuwanie cząstki w nowe położenie ...............................................................................................345 Obliczanie nowej prędkości ......................................................................................................................346 Korygowanie prędkości przed zderzeniem .........................................................................................347 Przykład — piłka odbijająca się od nachylonej ściany ....................................................................349 Przykład — piłka odbijająca się od wielu ścian ..................................................................................353 Zderzenia między cząstkami w jednym wymiarze . ..........................................................................354 Przenoszenie cząstek w nowe położenie .............................................................................................355 Zderzenia sprężyste . ...................................................................................................................................357 Zderzenia niesprężyste ...............................................................................................................................360 Zderzenia międzycząsteczkowe w dwóch wymiarach . ..................................................................362 Przykład — zderzenie dwóch cząstek w dwóch wymiarach .........................................................363 Przykład — zderzenia wielu cząstek ......................................................................................................366 Przykład — zderzenia wielu cząstek z odbiciami ..............................................................................366 Podsumowanie ..............................................................................................................................................370

Rozdział 12. Układy cząstek ....................................................................................371 Wprowadzenie do modelowania układów cząstek . ........................................................................372 Uzyskiwanie ciekawych efektów w animacjach z udziałem układów cząstek ........................373 Prosty przykład — rozbryzg wody ..........................................................................................................373 Przygotowanie emitera cząstek ...............................................................................................................376 Efekt dymu . .....................................................................................................................................................378 Efekt ognia . .....................................................................................................................................................382 Fajerwerki . .......................................................................................................................................................383 Układy cząstek i siły zasięgowe . ..............................................................................................................389 Ścieżka cząstek w polu siły .........................................................................................................................389 Tunele czasoprzestrzenne .........................................................................................................................392 Układy cząstek oddziałujących ze sobą . ...............................................................................................394 Układ wielu oddziałujących grawitacyjnie cząstek ..........................................................................395 Prosta symulacja ruchu gwiazd w galaktyce ......................................................................................399 Podsumowanie ..............................................................................................................................................403

12

Spis treści

Rozdział 13. Ciała złożone .......................................................................................405 Bryła sztywna ..................................................................................................................................................406 Podstawy opisu ruchu bryły sztywnej ...................................................................................................406 Modelowanie bryły sztywnej ....................................................................................................................411 Dynamika ruchu obrotowego bryły sztywnej ....................................................................................414 Symulacje uwzględniające dynamikę bryły sztywnej .....................................................................418 Przykład — prosta symulacja turbiny wiatrowej ...............................................................................421 Przykład — toczenie na równi pochyłej ...............................................................................................424 Zderzenia i odbicia ciał sztywnych .........................................................................................................430 Przykład — symulacja odbić bryły sztywnej .......................................................................................434 Przykład — zderzenie bloków ..................................................................................................................437 Ciała odkształcalne .......................................................................................................................................439 Układy sprężyn . .............................................................................................................................................439 Symulacja liny . ...............................................................................................................................................440 Symulacja tkaniny . .......................................................................................................................................445 Podsumowanie ..............................................................................................................................................447

Część IV. Tworzenie bardziej złożonych symulacji ................................................449 Rozdział 14. Metody całkowania numerycznego ..................................................451 Ogólne zasady całkowania numerycznego . .......................................................................................452 Określenie problemu . .................................................................................................................................452 Charakterystyka metod całkowania numerycznego .......................................................................454 Rodzaje metod całkowania .......................................................................................................................456 Przygotowanie klasy Forcer do wykonywania obliczeń różnymi metodami ..........................456 Całkowanie metodą Eulera .......................................................................................................................457 Całkowanie jawną metodą Eulera ...........................................................................................................458 Całkowanie niejawną metodą Eulera ....................................................................................................458 Całkowanie półjawną metodą Eulera ....................................................................................................459 Porównanie jawnej i półjawnej metody Eulera .................................................................................459 Wady i zalety metod Eulera .......................................................................................................................460 Całkowanie metodą Rungego-Kutty . ....................................................................................................461 Metoda Rungego-Kutty drugiego rzędu (RK2) ..................................................................................461 Metoda Rungego-Kutty czwartego rzędu (RK4) ................................................................................462 Stabilność i dokładność metod RK2 i RK4 w porównaniu z metodą Eulera . ...........................463 Całkowanie metodą Verleta . .....................................................................................................................465 Całkowanie położeniową metodą Verleta ...........................................................................................465 Całkowanie prędkościową metodą Verleta .........................................................................................467 Sprawdzenie stabilności i dokładności metod Verleta ...................................................................467 Podsumowanie ..............................................................................................................................................468

13

Spis treści

Rozdział 15. Pozostałe kwestie techniczne ............................................................469 Fizyka w trzech wymiarach .......................................................................................................................470 Różnica między fizyką w dwóch i w trzech wymiarach ...................................................................470 Matematyka w trzech wymiarach ...........................................................................................................470 Przygotowanie klas opisujących trójwymiarowe ciała i ich ruch ................................................476 Przygotowanie modeli trójwymiarowych ............................................................................................478 Przykład — obracający się sześcian ........................................................................................................480 Dołączanie bibliotek 3D ..............................................................................................................................483 Nieco na temat Stage3D .............................................................................................................................483 Przygotowywanie modeli w skali . ..........................................................................................................483 Uzyskiwanie realistycznych efektów ......................................................................................................484 Prosty przykład . .............................................................................................................................................484 Dobieranie jednostek . ................................................................................................................................484 Współczynniki skalowania i wartości parametrów ...........................................................................485 Skalowanie równań . ....................................................................................................................................486 Przygotowywanie dokładnych symulacji . ...........................................................................................487 Prowadzenie obliczeń na zmiennych typu Number ........................................................................487 Staranne dobranie metody całkowania ................................................................................................488 Dobranie odpowiedniego kroku obliczeń ...........................................................................................488 Staranne dobieranie warunków początkowych ................................................................................488 Ostrożność przy określaniu warunków brzegowych .......................................................................488 Podsumowanie ..............................................................................................................................................489

Rozdział 16. Projekty symulacji ...............................................................................491 Projekt łodzi podwodnej ............................................................................................................................491 Krótki opis teoretyczny ...............................................................................................................................492 Przygotowanie sceny ...................................................................................................................................492 Kod animacji . ..................................................................................................................................................492 Kod napędzający łódź . ................................................................................................................................494 Sterowanie i efekty wizualne ....................................................................................................................495 Pełny kod klasy SubmarineMover ...........................................................................................................496 Dalszy rozwój symulacji ..............................................................................................................................498 Symulator lotów ............................................................................................................................................499 Fizyka lotu a sterowanie samolotem . .............................................................................................499 Jak będzie wyglądać symulacja? . .....................................................................................................503 Przygotowanie sceny ............................................................................................................................504 Fizyka symulacji ......................................................................................................................................505 Mechanizm sterowania ........................................................................................................................509 Wyświetlanie informacji o locie . .......................................................................................................509 Sprawdzenie symulatora .....................................................................................................................510 Dalszy rozwój symulacji .......................................................................................................................511 14

Spis treści

Dokładny model Układu Słonecznego . ................................................................................................511 Nad czym będziemy pracować? ..............................................................................................................511 Nieco fizyki . .....................................................................................................................................................512 Wybranie odpowiedniego algorytmu ...................................................................................................512 Symulacja ruchu jednej planety w warunkach idealnych ..............................................................514 Dobranie współczynników skalowania .................................................................................................516 Dane dotyczące planet i warunków początkowych ........................................................................518 Prosty model Układu Słonecznego ........................................................................................................518 Wprowadzenie dokładnych warunków początkowych .................................................................523 Porównanie wyników symulacji z danymi z NASA ...........................................................................524 Dalszy rozwój symulacji . ............................................................................................................................527 Podsumowanie ..............................................................................................................................................527

Skorowidz ................................................................................................................529

15

Spis treści

16

O autorach Dev Ramtal zajmuje się oprogramowywaniem praw fizyki od ponad dwudziestu lat. Oprócz akademickiego wykształcenia w dziedzinie fizyki matematycznej i komputerowej może pochwalić się wieloletnim doświadczeniem w pisaniu aplikacji internetowych — swoją pierwszą stronę stworzył w 1997 roku. Od sześciu lat korzysta z Flasha jako narzędzia w swojej pracy badawczej oraz dydaktycznej, do tworzenia aplikacji internetowych, a także dla rozrywki. Jego coraz większą pasją staje się pisanie gier komputerowych. Uzyskał tytuł magistra i doktora fizyki na Uniwersytecie Londyńskim. Dev mieszka w Wielkiej Brytanii, jest naukowcem. Można się z nim skontaktować poprzez witrynę www.physicscodes.com.

Adrian Dobre ma ponadpiętnastoletnie doświadczenie w badaniu i komputerowym modelowaniu dynamiki płynów. Jako naukowiec i dydaktyk zainteresował się językiem ActionScript oraz oprogramowaniem Flash, ponieważ za pomocą tych narzędzi można tworzyć w pełni wartościowe i zarazem atrakcyjne wizualnie programy. Od ponad pięciu lat wykorzystuje ActionScript do tworzenia wirtualnych laboratoriów oraz komputerowych modeli obrazujących prawa fizyki. Adrian uzyskał tytuł magistra inżyniera aeronautyki na Politechnice w Bukareszcie oraz tytuł doktora nauk technicznych uczelni University of Western Ontario w Kanadzie. Aktualnie mieszka wraz ze swą rodziną w Bukareszcie, w Rumunii.

O recenzencie technicznym książki R.J. Owen jest starszym projektantem oprogramowania pracującym dla Effective UI. Korzysta ze środowiska programistycznego Flex od czasu, gdy ukazała się jego druga wersja. Brał udział w rozwijaniu wielu mniejszych i większych projektów programistycznych, zawsze starając się wybierać te, w których istotną rolę grało tworzenie bogatego interfejsu użytkownika. R.J. prowadzi blog, a także wygłasza wykłady podczas rozmaitych sympozjów i imprez specjalistycznych, na przykład 360|Flex, Adobe Max oraz O’Reilly’s Web 2.0; R.J. chętnie angażuje się w projekty, które pomagają specjalistom zdobywać wiedzę z dziedzin wykraczających poza obszar programowania. Ukończył studia podyplomowe z fizyki i informatyki. R.J. mieszka z rodziną w Kolorado.

17

Wprowadzenie do fizyki w grach, animacjach i symulacjach Flash

O twórcy grafiki na okładce książki Grafika z przedniej okładki niniejszej książki została zaprojektowana przez Corné van Doorena. Jest ona połączeniem form technologicznych z organicznymi, które powstało, gdy Corné przerwał na jakiś czas współpracę z przyjaciółmi z ED specjalnie po to, by zająć się wykonaniem projektu graficznego na potrzeby serii wydawniczej Foundation. Grafika z okładki tej książki znalazła się także na okładkach kilku innych książek. Corné w dzieciństwie rysował na wszystkim, co wpadło mu w ręce, następnie zaś zaczął odkrywać nieskończenie bogaty świat multimediów — multimedialna podróż van Doorena trwa po dziś dzień. Jego mantrą było i jest zdanie „Jedynym ograniczeniem dla multimediów jest wyobraźnia ich twórcy”. Powtarzając to motto, Corné znajduje motywację do ciągłego rozwijania się. Corné wykonuje zlecenia klientów z różnych krajów świata, pisze artykuły do magazynów o multimediach oraz rozprawy dotyczące multimediów, testuje i recenzuje oprogramowanie, jak również pracuje nad oprawą wizualną książek przyjaciół z ED. Jeśli chcesz obejrzeć jego prace lub skontaktować się z nim, odwiedź stronę www.cornevandooren.com.

Podziękowania Jesteśmy bardzo wdzięczni wszystkim osobom, zarówno z Apress, jak i spoza wydawnictwa, dzięki którym mogliśmy urzeczywistnić nasz pomysł napisania niniejszej książki. Proces wydawniczy wymaga wielkich nakładów pracy nie tylko ze strony autorów — pisanie to zaledwie część zadania, jakie trzeba wykonać, by wydać książkę. My mieliśmy naprawdę wielkie szczęście współpracować z zespołem wspaniałych ludzi — nie wymieniamy tu żadnych imion ani nazwisk, ponieważ pragniemy uniknąć ryzyka pominięcia kogokolwiek w podziękowaniach. Podziękowania kierujemy również do społeczności programistów i użytkowników Flasha, którzy tak otwarcie dzielą się swoimi spostrzeżeniami oraz wiedzą na blogach, forach, stronach WWW oraz w książkach. Niezwykle się cieszymy, że mając dostęp do tak wielkich zasobów informacji, mogliśmy stworzyć i dać coś w zamian. Na koniec pragniemy podziękować także naszym rodzinom za nieustające wsparcie i cierpliwość w czasie, gdy intensywnie pracowaliśmy nad książką.

18

Przedmowa Mamy nadzieję, że czytanie tej książki sprawi Ci tyle przyjemności, ile nam dało jej pisanie. Oprogramowywanie praw fizyki w środowisku programistycznym Flash jest świetną zabawą — tworzenie obiektów za pomocą kilku linijek kodu po to, by zobaczyć, że zachowują się jak w prawdziwym świecie, daje niemałą satysfakcję. Środowisko Flash daje nam — programistom — wielkie możliwości. Niniejsza książka powstała po to, by pokazać Ci, w jaki sposób z nich korzystać. Niezależnie od tego, czy pragniesz tworzyć wiarygodnie wyglądające animacje, gry, w których obiekty zachowują się realistycznie, czy dokładne symulatory różnych układów i zjawisk, znajdziesz tu dużo przydatnych informacji, pomysłów i pomocnych przykładów. Inspiracją do napisania tej książki stała się inna publikacja — doskonała praca autorstwa Keitha Petersa zatytułowana Foundation ActionScript Animation. Była to pierwsza książka, jaką przeczytaliśmy, gdy kilka lat temu oswajaliśmy się z oprogramowaniem Flash oraz językiem ActionScript. Zawiera ona omówienie wielu tematów związanych z oprogramowywaniem praw fizyki w środowisku Flash i pokazuje niebotyczne możliwości, jakie daje owo środowisko, jeśli chcemy tworzyć realistyczne interaktywne animacje, których wykonywanie i oglądanie będzie prawdziwą przyjemnością. W ciągu ostatnich lat prawdziwie uzależniliśmy się od środowiska Flash oraz języka ActionScript, korzystając z tych narzędzi do pisania licznych symulacji praw fizyki oraz innych programów. W trakcie pracy nad rozmaitymi aplikacjami wiele się nauczyliśmy, poznaliśmy rozwiązania różnych problemów i uznaliśmy, że warto tą wiedzą podzielić się ze społecznością użytkowników oprogramowania Flash. Książka napisana przez Keitha Petersa jest świetnym wprowadzeniem do zagadnień związanych z tworzeniem animacji obrazujących prawa fizyki, lecz w naszej opinii brakowało dotychczas na półkach księgarń pozycji zawierającej bardziej złożone i głębsze spojrzenie na kwestie związane z oprogramowywaniem fizyki, tworzeniem skomplikowanych aplikacji takich jak symulatory zjawisk fizycznych oraz gry komputerowe. Wydano już niejeden „podręcznik do fizyki w grach” dla programistów piszących w innych językach programowania, na przykład w C++ i Javie, więc dlaczego nie miałaby powstać podobna książka dla osób zainteresowanych ActionScriptem? Pragniemy, by nasza praca wypełniła właśnie tę lukę na rynku wydawniczym. Od razu na wstępie chcemy powiedzieć, że pisząc tę książkę, skupiliśmy się bardziej na omówieniu zagadnień związanych z fizyką niż na kwestiach dotyczących korzystania ze środowiska Flash. W naszej pracy znajdziesz więcej informacji na temat tego, jak za pomocą Flasha tworzy się realistyczne modele fizyczne, niż na temat metod wykonywania atrakcyjnych animacji interaktywnych. Niektóre z opisanych przez nas symulacji mogą wydawać się dość proste lub wręcz niezbyt atrakcyjne wizualnie, z pewnością jednak nie zabraknie w nich porządnie zaprogramowanej fizyki! Naszym głównym celem było przedstawienie prawdziwej, poważnej fizyki w przystępny sposób. Jednocześnie mamy nadzieję, że — choć nie unikaliśmy wchodzenia w szczegóły techniczne omawianych zagadnień, z niezbędną matematyką włącznie — udało nam się przedstawić istotną wiedzę jasno i bez zbędnego jej komplikowania. Z oczywistych przyczyn, dysponując ograniczonymi miejscem i czasem, nie byliśmy w stanie omówić wszystkich wartych uwagi zagadnień, niektóre zaś omówiliśmy pobieżnie. Mimo to nasza książka zawiera mnóstwo wiedzy — z pierwszego rozdziału dowiesz się, jak na bazie zaledwie kilku linijek kodu stworzyć animację przedstawiającą odbijającą się piłkę, w ostatnim zaś znajdziesz opis bardzo dokładnej symulacji całego systemu słonecznego. Mamy nadzieję, że odkrycie wszystkiego, co zawarliśmy pomiędzy pierwszym i ostatnim rozdziałem, da Ci mnóstwo radości!

19

Przedmowa

Czego się nauczysz z naszej książki (a czego się z niej nie dowiesz)? Wprowadzenie do fizyki w grach, animacjach i symulacjach Flash to pozycja, z której dowiesz się, jak wprowadzać fizykę do pisanych przez siebie programów. Czytając naszą książkę, nie nauczysz się programowania. Nie nauczysz się także korzystania z języka ActionScript. Mimo że niniejsza praca opisuje zagadnienia związane z implementowaniem praw fizyki w grach oraz innego rodzaju aplikacjach, nie jest ona podręcznikiem do pisania gier w dosłownym znaczeniu tych słów. Pisząc tę książkę, założyliśmy, że jej odbiorca będzie choć w minimalnym stopniu zaznajomiony z programowaniem w języku ActionScript 3.0 (AS3.0) oraz z obsługą oprogramowania umożliwiającego tworzenie aplikacji flashowych w AS3.0, na przykład środowiska Adobe Flash w wersji CS3 lub nowszej albo Adobe Flash Builder (dawniej Adobe Flex Builder). Z naszej książki nie dowiesz się, jak korzystać z wymienionych narzędzi. Jeśli nigdy ich nie używałeś, proponujemy, żebyś zapoznał się z jednym z wielu dostępnych na rynku wspaniałych podręczników do nauki obsługi środowiska programistycznego Flash oraz programowania w ActionSripcie. Pośród książek wartych polecenia wymienilibyśmy Foundation ActionScript 3.0 for Flash and Flex autorstwa Darrena Richardsona i Paula Milbourne’a. Gorąco polecamy Ci także zapoznanie się z Foundation ActionScript 3.0 Animation: Making Things Move! Keitha Petersa. Nie zakładamy natomiast, że znasz fizykę; oczekujemy od Ciebie tylko wiedzy matematycznej na poziomie szkoły podstawowej. Jeden z rozdziałów niniejszej książki poświęciliśmy na wyjaśnienie bardziej skomplikowanych koncepcji i zaprezentowanie narzędzi matematycznych, których znajomość najprawdopodobniej przyda Ci się podczas czytania naszego podręcznika. Całą niezbędną wiedzę z fizyki podaliśmy w zwartej, niewymagającej sięgania do innych materiałów formie. Ponadto w książce tej znajdziesz pełny kod źródłowy wielu aplikacji, które obrazują wykorzystanie świeżo przyswojonej przez Ciebie wiedzy.

Ogólnie o książce Niniejsza książka została podzielona na cztery części. Część I „Podstawy” (rozdziały od 1. do 4.) — jest wprowadzeniem zawierającym wiedzę z matematyki i fizyki, która stanowi podstawę wszystkich pozostałych części podręcznika. Znajdziesz w niej również opis wybranych zagadnień dotyczących programowania w języku ActionScript 3.0 — tych, które są szczególnie ważne podczas oprogramowywania praw fizyki we wspomnianym języku programowania. Część II „Cząstki, siły i ruch” (rozdziały od 5. do 10.) — zaczyna się rozdziałem, w którym podaliśmy prawa fizyki opisujące ruch cząstki w polu siły dowolnego rodzaju (rozdział 5.). W następnych rozdziałach korzystamy z tych praw, by wprawić różne obiekty w ruch wywołany lub modyfikowany przez rozmaite rodzaje sił: grawitacji, tarcia, oporu, wyporu, wywierane na ciało przez wiatr, sprężyste, centralne i wiele innych. W tej części książki skupiliśmy się tylko na zagadnieniu tworzenia symulacji ruchu cząstek oraz innych prostych obiektów. W części III, zatytułowanej „Układy wielu cząstek i układy wielopokoleniowe” (rozdziały od 11. do 13.), pokazaliśmy, jak tworzy się modele bardziej złożonych układów fizycznych, w tym układów wielu oddziałujących ze sobą cząstek oraz większych obiektów. We wspomnianych układach poszczególne cząstki i obiekty nie pozostają wobec siebie obojętne, lecz wzajemnie ze sobą oddziałują, co wpływa na sposób, w jaki się poru-

20

Przedmowa

szają. Opisaliśmy trzy rodzaje oddziaływań — zderzenia oraz siły krótkiego i dalekiego zasięgu. W tej części znajdziesz omówienie układów wielu cząstek, a także zagadnień dotyczących bryły sztywnej i ciał odkształcalnych. Część IV „Tworzenie bardziej złożonych symulacji” (rozdziały od 14. do 16.) poświęciliśmy zagadnieniu modelowania złożonych symulacji, w przypadku których szczególnie ważne są realizm i dokładność odwzorowania praw fizyki, nie zaś wizualna strona animacji. W tej części książki znajdziesz omówienie metod całkowania numerycznego oraz innych numerycznych i technicznych problemów z dziedziny programowania, takich jak tworzenie modeli w skali i modeli trójwymiarowych. Część IV książki kończy się podaniem przez nas kilku przykładów projektów symulacji, które odwzorowują prawa fizyki.

Kod źródłowy i przykłady Wszystkie fragmenty kodu źródłowego użyte w tej książce można pobrać pod adresem: ftp://ftp.helion.pl/ przyklady/wprofi.zip Kod źródłowy jest kompatybilny z oprogramowaniem Adobe Flash w wersji CS3 lub nowszej (niektóre przykłady działają tylko w wersji CS4) oraz Adobe Flex/Flash Builder w wersji 3 lub nowszej. Cały kod źródłowy został napisany w języku ActionScript. Nie używaliśmy MXML ani właściwości środowiska Flex. Zachęcamy Cię do zmieniania naszego kodu i wykorzystywania go podczas tworzenia własnych projektów. Pracując nad recenzją techniczną tego podręcznika, R.J. Owen zauważył, że interesującym pomysłem byłoby stworzenie strony WWW, na której nasi czytelnicy pokazywaliby stworzone przez siebie fragmenty kodu — w ten sposób dowiedzielibyśmy się, jakie możliwości dają ludziom udostępnione przez nas przykłady. Uznaliśmy ten pomysł za świetny i założyliśmy witrynę, w której znajdziesz więcej przykładów kodu źródłowego i w której sam możesz podzielić się swoim kodem z innymi programistami; oto jej adres: www. physicscodes.com/as3book.

21

Przedmowa

22

Część I

Podstawy

23

Część I

24

Rozdział 1.

�

Wprowadzenie do oprogramowu�11a ��"'S ·· zjawisk fizycznych

�

Wybrałeś tę książkę, zakładamy zatem, że jesteś zai ny wprowadzeniem fizyki do swoich projektów programistycznych. Czy zastanawiałeś się je n go miałbyś to robić, co Ci to może dać, czy jakich umiejętności będzie to od Ciebie wymagać? ro dział powinien rozwiać wszystkie Twoje wątpliwości.

�jących tematów:

Znajdziesz tu między innymi omówienie n Po co modeluje się zjawisk

•

dne?

W tym podrozdziale wyjaśnimy, dlaczego czasami warto uwzględniać w programa c wisty przebieg zjawisk fizycznych. się uchylić rąbka tajemnicy i wyjaśnić Ci w prostych słowach, czym Czym jest fizyka? Po t skrócie wszystko to, co powinieneś wiedzieć. jest fizyka. Opisze� Oprogramowy� � jawisk fizycznych. Na szczęście opisywanie zjawisk fizycznych kodem programu nie jest tak skomplikowane, jak mogłoby się wydawać. Ten podrozdział wyjaśni Ci wszystko, co powinieneś wiedzieć na ten temat. Prosty przykład. Aby pokazać Ci, na czym polega oprogramowywanie fizyki, przedstawimy prosty problem, którego rozwiązanie nie wymaga rozległego kodowania.

�

Po co modeluje się zjawiska fizyczne? Istnieje wiele przyczyn, dla których wprowadza się fizykę do aplikacji flashowych. Nietrudno jest wymienić kilka najbardziej oczywistych powodów.

25

Rozdział 1.

Uzyskanie realistycznie wyglądających efektów

Ludzie decydują się na tworzenie aplikacji we Flashu głównie dlatego, że narzędzie to pozwala w bardzo wygodny i łatwy sposób uzyskać ładnie wyglądające animacje. Jeśli Flash wzbogacimy o skrypty języka ActionScript i uwzględnimy prawa fizyczne, zachowanie animowanych obiektów będzie do złudzenia przy­ pominać to, co znasz z codziennego życia. Wyobraź sobie, że na przykład masz do zrealizowania animację, w której ktoś kopie piłkę, a ona odbija się od ziemi. Gdybyś zdecydował się wykonywać ją wyłącznie w Adobe Flash, mógłbyś spróbować uzyskać odpowiedni efekt, stosując funkcję Animacja kształtu, jednak odtwarzanie stadiów ruchu poprzez generowanie położenia obiektu pomiędzy zadanymi punktami począt­ kowym i końcowym nigdy nie pozwoli otrzymać w rezultacie naturalnie wyglądającej animacji. Wystarczy jednak nauczyć się tworzyć proste skrypty i liznąć nieco fizyki, by uzyskać zaskakująco realistyczne efekty. Jeśli zaś czujesz się przede wszystkim programistą, a projektantem w znacznie mniejszym stopniu (jak autorzy tej książki), najpewniej podejście zaprezentowane w tym miejscu uznasz za jesz,prostsze! Przykład umieszczony na końcu tego rozdziału pokaże Ci, jakie to łatwe. ""-

"'

T

t

�

����� o�e� ; :,�ą�i� � ���i�!:n:; ����!,��;o�i�w?� Fla'h Player ni� ustannie rosną, same gry stają się coraz bardziej złożone. Sły� �wniej orogramu przyśpieszaniu sprzęto­

�

wym i układach obsługujących grafikę trójwymiarową u ·es � bezpośrednio na kartach graficznych, ale to tylko dwie spośród powstałych ostatnio metod, dz 'rym granie w gry komputerowe stało się znacznie przyjemniejsze. Ale o tym, czy gra sprawia r e alistycznej, decyduje nie tylko jej wydajność i wygląd modeli - równie ważne jest poczucie r ości oglądanych na ekranie scen. Gdy rzucasz · działania siły grawitacji, gdy wystrzeliwujesz pod piłką, powinna ona poruszać się po torze wodą torpedę, musi się ona poruszać inac �- p ka w powietrzu. Innymi słowy, w grach musi pojawiać się fizyka.

�

·� WY.�

�e'CJ jJ 350){ // Po uderzeniu o ziemię vy *= -0.8; // pionowa składowa prędkości zmienia zwrot, a jej wartość maleje. } } } }

Nie wpadaj w panikę, jeśli klasy AS3.0 nie są Twoją najmocniejszą stroną — w następnym rozdziale wyjaśnimy dokładnie, jak działają poszczególne partie kodu. Najważniejsze jego fragmenty — te, w których znajdziesz modelowanie zjawisk fizycznych — opisaliśmy komentarzami. Zmienna g to przyśpieszenie grawitacyjne. W kodzie przypisaliśmy mu taką wartość, dla której animacja wygląda realistyczne. Następne dwie linie zawierają deklaracje zmiennych odpowiadających poziomej i pionowej składowej prędkości piłki. Za obliczenia pozwalające wyznaczyć wielkości fizyczne opisujące ruch piłki odpowiedzialna jest funkcja onEachTimestep(), wykonywana z częstotliwością odpowiadającą liczbie klatek animacji przypadających na sekundę. W czasie obliczeń zwiększa się wyłącznie wartość zmiennej vy, natomiast wartość zmiennej vx jest stała — wynika to z faktu, że siła grawitacji działa tylko w pionie. Po określeniu nowych wartości prędkości przystępujemy do wyznaczenia nowych wartości współrzędnych piłki — odbywa się to przez dodanie wartości zmiennych vx i vy do wartości zmiennych x i y. Ostatni krok obliczeń odpowiada za uzyskanie efektu odbicia.

34

Wprowadzenie do oprogramowywania zjawisk fizycznych

Uruchom teraz skrypt i zobacz, jak on działa. Wygląda bardzo realistycznie, prawda? Jak to możliwe, że tak krótki kod pozwala na tak dokładne sterowanie torem ruchu piłki? To przecież prawie magia. Spróbuj osiągnąć taki sam efekt, korzystając z funkcji Adobe Flash Animacja kształtu! Czy to naprawdę tak proste? Oczywiście, że nie! Ten kod to zaledwie przedsmak tego, co możesz osiągnąć. To dobry początek (możesz poklepać się od nas po plecach), ale taka symulacja może stać się znacznie bardziej realistyczna. To oczywiście będzie wymagać wprowadzenia dodatkowych warunków fizycznych, nie obejdzie się także bez zastosowania większej ilości kodu. Można na przykład uwzględnić tarcie, które w chwili zetknięcia z ziemią będzie zmniejszać prędkość poziomą piłki. Wyobraź sobie, że projektujesz grę, w której piłka ma swobodnie unosić się w powietrzu. Wtedy warto byłoby dodać do symulacji efekt oporu, jakiego doznają ciała poruszające się w atmosferze, a także uwzględnić ruch piłki pod wpływem podmuchów wiatru. Gdyby piłka miała wpadać do wody, można by wzbogacić kod o fragmenty odpowiedzialne za tonięcie piłki i wznoszenie się jej na powierzchnię. W takiej symulacji przed osiągnięciem stanu równowagi piłka przez pewien czas wykonywałaby drgania na linii wody. Można też opracować symulację zderzeń wielu piłek albo stworzyć model obrazujący zachowanie się ciał w polu grawitacyjnym Ziemi. To ostatnie wymagałoby starannego dobrania warunków brzegowych oraz opracowania dokładnego i stabilnego algorytmu naliczania czasu. Po zakończeniu pracy z tą książką będziesz potrafił wszystko to oraz parę innych rzeczy. Będziesz też doskonale wiedział, co zrobić, by osiągnąć zaplanowany cel. Obiecujemy.

Podsumowanie Fizyka to matematyczne ujęcie praw natury. Zasady te są proste, więc bardzo łatwo można zapisać je w postaci kodu, dlatego uzyskiwanie w ten sposób naturalnie wyglądających animacji wcale nie jest trudne. Aby zaprogramować symulację zjawiska fizycznego, trzeba wykonać następujące kroki — musisz określić, co dzieje się w trakcie trwania zjawiska, opisać to odpowiednimi równaniami, opracować algorytm, który rozwiąże równania, i zapisać go w postaci kodu. Oznacza to, że stworzenie dobrej symulacji będzie wymagać wiedzy z czterech różnych dziedzin — fizyki, matematyki, metod numerycznych i programowania. Książka ta pozwoli Ci poznać podstawy trzech pierwszych — zakładamy, że programowanie w ActionScripcie nie jest Ci obce. W związku z powyższym w następnym rozdziale znajdziesz bardzo pobieżne omówienie wybranych zagadnień dotyczących języka ActionScript 3.0. Zwrócimy w nim uwagę przede wszystkim na te aspekty, które będą szczególnie przydatne podczas programowania symulacji o charakterze fizycznym.

35

Rozdział 1.

36

Rozdział 2.

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia Trzecia wersja języka skryptowego ActionScript różni się znacząco od swoich poprzedniczek. W tym rozdziale znajdziesz skrótowy opis tych elementów AS3.0, które będą Ci potrzebne w czasie dalszej pracy z naszą książką. Nie szukaj tu pełnego kompendium wiedzy na temat AS3.0, gdyż rozdział ten ma w założeniu jedynie podsumować te wiadomości, które będą niezbędne do przyswojenia kodu przykładowych programów, jakie zaprezentujemy dalej. Poza tym chcieliśmy przedstawić w nim te zagadnienia związane z tworzeniem aplikacji we Flashu i ActionScripcie, które sprawiają, że dodawanie do programu symulacji fizycznych ma sens. Rozdział ten jest przeznaczony dla czytelników, którzy mają podstawową wiedzę z zakresu pracy z programem Flash i tworzenia skryptów języka ActionScript. Jeśli masz spore doświadczenie w programowaniu w AS3.0, większość tego rozdziału nie będzie dla Ciebie zbyt interesująca — w takim przypadku możesz zapoznać się pokrótce z materiałem umieszczonym na jego końcu, a dotyczącym tworzenia animacji w ActionScripcie i wykrywania zderzeń. Jeżeli zaś nie miałeś nigdy dotąd do czynienia z programowaniem w tym języku, powinieneś najpierw zapoznać się z którąś z książek, jakie wymieniliśmy w „Podsumowaniu”. Jeżeli znasz wcześniejsze wersje języka ActionScript lub uważasz, że musisz odświeżyć sobie wiedzę dotyczącą wersji trzeciej, powinieneś dokładniej zapoznać się z treścią tego rozdziału. Wprawdzie powtórzenie wiadomości nie sprawi, że z dnia na dzień staniesz się biegłym programistą języka ActionScript, ale z pewnością pozwoli Ci korzystać z podanych w książce przykładów i rozwijać je w żądanym kierunku bez nadmiernego wysiłku. Omówimy tu następujące zagadnienia: ƒ

Klasy w języku ActionScript 3.0 — klasy i obiekty to podstawowe struktury danych programowania obiektowego (OOP). Każdy przedmiot z otaczającego Cię świata w języku ActionScript będzie reprezentowany odpowiednim obiektem. Każdy z obiektów ma swoje właściwości, a stosując odpowiednie metody, może podejmować określone działania.

37

Rozdział 2.

ƒ

Podstawy programowania w języku ActionScript 3.0 — dla pełności obrazu przedstawimy tu podstawowe elementy języka AS3.0: zmienne, typy danych, tablice, operatory, funkcje, logikę i pętle, zaprezentujemy też składnię, która pozwala wykorzystać je wszystkie do tworzenia programów.

ƒ

Zdarzenia w języku ActionScript 3.0 — obsługa zdarzeń w AS3.0 i ich konstrukcja różnią się znacznie od tego, co możesz znać z poprzednich wersji języka. Pokrótce przedstawimy składnię zdarzeń, omówimy też kilka przykładów, które pozwolą Ci zrozumieć, w jaki sposób skłonić program do reagowania na działania użytkownika.

ƒ

Układ współrzędnych we Flashu — stanowi on odpowiednik przestrzeni roboczej znanej z programu Adobe Flash. Odpowiednie instrukcje programu pozwolą Ci umieszczać obiekty w dowolnie wybranych miejscach dwu- lub trójwymiarowej sceny. Wskażemy tu różnice pomiędzy zwykłym układem kartezjańskim, z jakiego korzysta się w matematyce, a układem współrzędnych stosowanym we Flashu.

ƒ

Graficzny interfejs programowania Flasha — umiejętność tworzenia rysunków za pomocą samego kodu, szczególnie w połączeniu ze znajomością matematyki i fizyki, jest niezwykle potężnym narzędziem pracy. W tym podrozdziale znajdziesz krótki opis najczęściej stosowanych metod interfejsu graficznego AS3.0. Będą się one pojawiać w większości przykładów podawanych w książce.

ƒ

Tworzenie animacji w języku ActionScript — w tym fragmencie omówimy sposoby tworzenia animacji za pomocą kodu, wyjaśnimy też zasadę działania najważniejszej z metod wykorzystywanych do tworzenia symulacji fizycznych. Będziesz mieć z nią do czynienia we wszystkich przedstawianych dalej przykładach.

ƒ

Wykrywanie zderzeń — w grach oraz w każdym projekcie, w którym pojawia się ruch, należy liczyć się z tym, że poszczególne obiekty będą na siebie wpadać. Algorytmy detekcji zderzeń pozwalają stwierdzić, w którym momencie doszło do zetknięcia się ze sobą dwóch ciał, dzięki czemu program może na to zareagować w odpowiedni sposób.

Klasy w języku ActionScript 3.0 Wcześniejsze wersje języka ActionScript 3.0 pozwalały programować bez odwoływania się do klas, teraz jednak jest to niemożliwe, gdyż klasy trafiły do struktury samego języka. Zatem należy odpowiedzieć sobie na pytania, czym są klasy i jak z nimi pracować. Klasa jest podstawowym elementem każdego języka obiektowego. Stanowi ona teoretyczny opis obiektu, który chcesz utworzyć. Obiektem zaś jest każdy element pojawiający się na scenie w czasie trwania animacji. To bardzo abstrakcyjny opis, pozwól zatem, że posłużymy się przykładem. Załóżmy, że w projekcie, nad którym pracujesz, mają pojawiać się cząstki i chcesz, by każda z nich była obiektem. Skąd Flash ma zaczerpnąć informacje o tym, jak utworzyć cząstkę? Przede wszystkim musisz poinformować go, z czego składa się taka cząstka, jak będzie wyglądać, jak będzie się zachowywać i tak dalej. To zadanie realizuje klasa Particle obiektu, jakim jest każda cząstka. (Przyjęło się, że nazwy klas rozpoczynamy wielką literą). Za każdym razem, gdy będziesz chciał utworzyć nową cząstkę, wywołasz klasę Particle. W następnym podrozdziale opiszemy, w jaki sposób na podstawie istniejących klas tworzy się obiekty, podamy sposób definiowania klas i wyjaśnimy, z czego składa się klasa.

38

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Klasy i obiekty Przyjrzyj się ponownie zapisowi klasy BouncingBall znanej Ci już z poprzedniego rozdziału. Funkcja init() przedstawia sposób powołania do życia obiektu na podstawie istniejącej klasy. private function init():void { ball = new Ball(); ball.x = 50; ball.y = 75; addChild(ball); addEventListener(Event.ENTER_FRAME,onEachTimestep); }

Obiekt ball jest tak zwaną instancją klasy Ball. Instancja zostaje powołana do życia kodem: ball = new Ball();

Następnie przechodzimy do wyświetlenia obiektu (co jest równoznaczne z dodaniem go do listy Wyświetlaj): addChild(ball);

Zauważ, że cała animacja we Flashu ma postać klasy (widać to między innymi na listingu przedstawionym w rozdziale 1.). W wersjach Adobe Flash od CS3 do CS5 jest ona nazywana klasą dokumentu, w Flex Builder 3 i Flash Builder 4 (w których tworzy się projekty w czystym ActionScripcie) nazywa się ją zazwyczaj główną klasą aplikacji lub podobnie.

Budowa klasy w AS3.0 Dobrze, wiesz już, jak na podstawie istniejącej klasy powołać do życia obiekt, ale jak w ogóle wygląda klasa w języku AS3.0? Oto przykładowy kod zupełnie poprawnie skonstruowanej klasy, która niczego nie robi: package{ public class NicNieRob { public function NicNieRob() { } } }

Ciało klasy znajduje się wewnątrz wyrażenia package{}. Wyrażenie to, tak zwany pakiet, przypomina nieco folder — pozwala łączyć powiązane ze sobą klasy. Domyślny pakiet nie ma żadnej nazwy, jak w tym przykładzie, ale jeśli chcesz, możesz nazwać go dowolnie, na przykład package mojpakiet{}. Wyrażenie public class NicNieRob{} stanowi deklarację klasy o nazwie NicNieRob. Klasa zwiera funkcję (a dokładniej rzecz biorąc, metodę) o tej samej nazwie — w tym przypadku NicNieRob(). Funkcja ta jest tak zwanym konstruktorem klasy. Słowo kluczowe public określa zasięg działania klasy, funkcji lub właściwości (wkrótce wyjaśnimy, czym są właściwości). Oznacza ono, że zarówno klasa NicNieRob, jak i funkcja NicNieRob są dostępne spoza ciała klasy. Klasa może zawierać także funkcje prywatne (private) dostępne tylko z ciała klasy oraz funkcje chronione (protected) dostępne dla jej klas potomnych (w następnym podrozdziale przedstawimy ideę dziedziczenia). Przykłady funkcji prywatnych i chronionych pojawią się niebawem. Następne podrozdziały poświęciliśmy szerszemu wyjaśnieniu przedstawionych powyżej idei.

39

Rozdział 2.

Funkcje, metody i konstruktory Funkcja przedstawiona w poprzednim podrozdziale grała rolę konstruktora klasy. Kod zawarty wewnątrz konstruktora jest wykonywany automatycznie za każdym razem, gdy program, za pomocą słowa kluczowego new, powoła do istnienia obiekt będący nową instancją tej klasy. W przykładzie opisującym ruch odbijającej się piłki wewnątrz konstruktora klasy wywoływana jest funkcja init(). Zauważ, że init() działa wyłącznie prywatnie, więc można się do niej dostać (a zatem także ją wywołać) wyłącznie z ciała klasy BouncingBall. Dlaczego postanowiliśmy wydzielić funkcję init(), zamiast umieścić jej kod bezpośrednio w ciele konstruktora? Wynika to stąd, że kod umieszczany bezpośrednio w konstruktorze jest interpretowany, a nie kompilowany. Zastosowane przez nas rozwiązanie przyśpiesza działanie programu. Funkcja init() to funkcja typu void (w AS2.0 typ ten nazywał się Void, pisane przez wielkie V), co oznacza, że nie zwraca ona żadnych danych. Funkcje mogą zwracać wyniki różnego typu, na przykład podana poniżej funkcja zwraca wygenerowaną losowo liczbę z zakresu od 0 do 100. private function randomNumber():Number { return(Math.random()*100); }

W AS3.0, tak samo jak miało to miejsce w drugiej wersji języka, każda funkcja może przyjmować argumenty lub parametry, czyli wartości początkowe, z jakimi ma być uruchomiona. Podana poniżej funkcja doda do siebie dwie wartości liczbowe podane jej w postaci argumentów i zwróci wynik w postaci liczby. private function addNumbers(x:Number,y:Number):Number { return(x+y); }

Publiczne metody klasy są dostępne poprzez zastosowanie operatora „kropka”; zapis ten znasz już zapewne z AS2.0. Przykładowo jeśli w klasie Samochod znajduje się publiczna funkcja rusz(), to zapis samochod.rusz() wywoła funkcję rusz() instancji samochod klasy Samochod.

Właściwości Doskonały przykład klasy, jaki podaliśmy wcześniej, sam w sobie nie nadaje się zbytnio do niczego. Przekształćmy go zatem w coś bardziej przydatnego, na przykład w narzędzie, które pozwoli dodać do siebie dwie liczby. Można to zrobić następująco: package{ public class RobCos { private var x:Numter = 2; private var y:Number = 3; public function RobCos() { var z:Number; z = x + y; trace(z); // Zapisz wynik na urządzeniu wyjściowym. } } }

40

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Tym razem w przykładowej klasie dzieje się już całkiem sporo. Przede wszystkim utworzyliśmy właściwości x, y i z. Język AS3.0 wymaga, by każda właściwość została zdefiniowana lub zadeklarowana, nim zostanie użyta. Deklarację przeprowadza się za pomocą słowa kluczowego var. Zauważ, że właściwości x i y zostały zadeklarowane jako prywatne, co oznacza, że są dostępne wyłącznie z poziomu klasy. „Z poziomu klasy” oznacza, że każda funkcja znajdująca się wewnątrz klasy ma dostęp do tych właściwości. Czy widzisz różnicę pomiędzy wspomnianymi wcześniej deklaracjami a deklaracją zmiennej z? Przed tą ostatnią nie pojawia się słowo kluczowe private. Dzieje się tak dlatego, że zmienna ta jest deklarowana wewnątrz funkcji i jako taka nie jest dostępna nigdzie poza nią. Gdyby została zgłoszona jako zmienna prywatna, stałaby się dostępna z każdego miejsca klasy. Skąd wiadomo, jak deklarować właściwości i funkcje — jako prywatne czy jako publiczne? Najprostsza zasada głosi, że wszystkie powinny pozostawać prywatne, chyba że muszą być dostępne także poza klasą. Stosowanie się do tej reguły pozwala uniknąć potencjalnych problemów wynikających z uszkodzenia kodu przez kod zewnętrznej aplikacji. Publiczne właściwości klasy w AS3.0 są, podobnie jak funkcje, dostępne za pośrednictwem operatora kropka. Na przykład wyrażenie ball.x zwraca wartość poziomej współrzędnej położenia piłki, ponieważ x jest zaimplementowaną w języku publiczną właściwością obiektów takich jak MovieClips czy Sprites (w wersji AS2.0 oznaczało się ją jako _x, z podkreśleniem na początku).

Statyczne metody i statyczne właściwości Metody i właściwości, którymi zajmowaliśmy się do tej pory, należały do obiektów, ale mogą one należeć również do klas. W takim przypadku do uruchomienia metody czy skorzystania z właściwości klasy nie trzeba wcześniej tworzyć instancji danej klasy. Przykładem może być tu polecenie Math.random(), dzięki któremu metoda klasy Math generuje liczbę losową. Deklarowanie właściwości i metod na poziomie klas odbywa się poprzez poprzedzenie ich słowem kluczowym static. Odwołania do statycznych metod i właściwości dokonuje się przez nazwę klasy, a nie jak pokazywaliśmy to wcześniej, przez nazwę instancji. Załóżmy na przykład, że w klasie Fizyka znajduje się następująca metoda statyczna (static): static public function obliczGrawitacje(masa:Number,g:Number):Number { return(masa*g); }

W takim przypadku wywołanie metody Fizyka.obliczGrawitacje(4, 9.8) spowodowałoby wyznaczenie siły, z jaką Ziemia przyciąga ciało o masie 4 kg.

Dziedziczenie Jedną z najważniejszych cech programowania obiektowego jest dziedziczenie, czyli opcja pozwalająca tworzyć nowe klasy na bazie już istniejących. Nowa klasa nazywana jest klasą pochodną (ang. subclass), klasę pierwotną zaś określa się mianem klasy bazowej (ang. superclass). Nowe klasy tworzy się za pomocą słowa kluczowego extends.

41

Rozdział 2.

Przykładowo aby z klasy Particle utworzyć klasę Electron, musielibyśmy zapisać następujący kod: package{ public class Electron extends Particle { public function Electron() { // Tu umieszczamy kod klasy Electron.

} } }

Klasa pochodna Electron będzie miała dostęp do wszystkich nieprywatnych właściwości i metod klasy bazowej Particle oraz oczywiście do wszystkich własnych. Aby wywołać konstruktor klasy bazowej, wystarczy odwołać się do funkcji super(). Zauważ, że w przykładowym kodzie z rozdziału 1. klasa BouncingBall rozszerza klasę Sprite. Każda klasa dokumentu musi rozszerzać klasę Sprite bądź MovieClip. W tym celu najpierw importuje się odpowiednią klasę lub pakiet (słowo kluczowe import), jak ma to miejsce w pliku BouncingBall.as.

Podstawy programowania w języku skryptowym ActionScript 3.0 Programowanie obiektowe to bardzo zmyślna koncepcja, ale na podstawie przykładów umieszczonych w poprzednim podrozdziale widać wyraźnie, że klasy same w sobie są raczej bezużyteczne. W tym podrozdziale przyjrzymy się tym elementom kodu, które biorą na siebie ciężar rzeczywistej pracy. Skupimy się przede wszystkim na ich znaczeniu dla obliczeń matematycznych i fizycznych.

Zmienne i stałe Czy pamiętasz słowo kluczowe var, którym deklarowaliśmy właściwości klasy? Słowo to jest skrótem angielskiego wyrażenia variable, oznaczającego zmienną. Zmienne służą do przechowywania wartości, przy czym wartość nie zawsze oznacza liczbę. Podana poniżej deklaracja powoła do życia zmienną przechowującą właśnie liczby (tu i w dalszych przykładach pomijamy słowo kluczowe private). var x:Number;

Oznacza to, że zmiennej x można przypisać wyłącznie wartości liczbowe, na przykład: x = 2;

Przypisanie wartości może pojawić się w tym samym wierszu co deklaracja zmiennej albo wystąpić w dowolnym miejscu kodu. var x:Number = 2;

Ponieważ zmienna x jest liczbą, można wykorzystywać ją w obliczeniach arytmetycznych. Podany poniżej kod zwiększa wartość zmiennej x określoną liczbę razy, następnie powiększa ją o wartość zmiennej y, a wynik obliczeń zapisuje w zmiennej z: z = 2*x + y;

42

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Zapis ten przypomina nieco równanie algebraiczne, ale różni się od niego pod kilkoma istotnymi względami. Pierwsza różnica jest wyłącznie kosmetyczna — składnia języka AS3.0 wymaga używania * jako operatora mnożenia. Do kwestii operatorów wrócimy jeszcze w dalszej części rozdziału. Druga różnica jest trudniej uchwytna i wiąże się ze znaczeniem operatora przypisania. Choć przytoczony powyżej fragment kodu wygląda dokładnie jak równanie algebraiczne, musisz pamiętać, że w rzeczywistości jest to polecenie przypisania określonej wartości do wskazanej zmiennej. Różnica pomiędzy przypisaniem a porównaniem staje się bardziej wyraźna w przykładzie tego rodzaju: x = x + 1;

Gdyby powyższy zapis był równaniem algebraicznym, wynikałoby z niego, że 0 = 1, co oczywiście jest niemożliwe. W tym przypadku oznacza to, że wartość zmiennej x (jakakolwiek by ona nie była) zostaje zwiększona o 1. Wartość zmiennej, jak wskazuje na to nazwa, może zostać zmieniona w każdej chwili. Jeśli chcemy, by zmienna przyjmowała zawsze określoną wartość, należy zadeklarować ją jako wartość stałą: const gravity:Number = 1;

Wartość stałej musi zostać zdefiniowana w chwili deklaracji. Wynika to stąd, że użycie słowa kluczowego const uniemożliwia wprowadzanie jakichkolwiek zmian wartości danej zmiennej w dalszej części kodu. Stosowanie stałych nie jest konieczne, ale wprowadzenie ich do kodu stanowi skuteczną metodę chronienia danych, których wartość w żadnym razie nie powinna się zmieniać. Zmienne programów pisanych w języku ActionScript mogą przyjmować też inne rodzaje wartości niż tylko liczbowe. Rodzaje te określa się mianem typów danych.

Typy danych Język AS3.0 oferuje różne rodzaje typów danych. Dzieli się je na dwie grupy — typy proste i typy złożone. Do typów prostych zaliczają się najbardziej podstawowe typy danych AS3.0. Są one przechowywane w pamięci w taki sposób, by zajmowały jak najmniej miejsca i były dostępne jak najszybciej. Z kolei złożone typy danych są zbudowane z odwołań do typów prostych. Wprawdzie wymagają większych zasobów pamięciowych, ale oferują programiście znacznie większą swobodę działania. Tabele 2.1 i 2.2 zawierają najpopularniejsze typy danych każdego z rodzajów. Tabela 2.1. Proste typy danych

Typ danych

Opis

Boolean

Typ logiczny, może przyjmować jedną z dwóch wartości — true albo false (alternatywnie 1 lub 0).

int

Liczby całkowite zapisywane w formacie 32-bitowym.

Number

Liczby zmiennoprzecinkowe o podwójnej precyzji zapisywane w formacie 64-bitowym.

String

Ciąg znaków 16-bitowych.

uint

Liczba całkowita bez znaku zapisana w formacie 32-bitowym.

43

Rozdział 2.

Tabela 2.2. Złożone typy danych

Typ danych

Opis

Object

Typ zdefiniowany w klasie Object, bazowej dla wszystkich definicji klas.

Array

Przechowuje listę danych dowolnego typu.

Vector

Odmiana typu Array. Zapisuje się w nim dane identycznego typu.

Sprite

Typ wyświetlający obiekt bez osi czasu.

MovieClip

Obiekt wyświetlający animację.

Bitmap

Obiekt wyświetlający nieruchomą mapę bitową.

Shape

Obiekt będący nieruchomym kształtem wektorowym.

ByteArray

Tablica danych binarnych.

TextField

Obiekt będący polem tekstowym.

Typy Number, int i uint omówimy dokładniej w następnym podrozdziale, teraz zaś chcielibyśmy powiedzieć kilka słów na temat pozostałych dwóch typów danych wymienionych w tabeli 2.1 — String i Boolean. Dane typu String to zbiory znaków. Następujący kod: var str:String = "Witaj!"; trace(str);

spowodowałby wyświetlenie na ekranie napisu Witaj!. Zawartość zmiennej typu String musi zawsze znajdować się w cudzysłowie bądź znakach apostrofu. Zmienne typu Boolean przyjmują tylko jedną z dwóch możliwych wartości — true lub false — na przykład: var bln:Boolean = false;

Zauważ, że wartość false nie została umieszczona w nawiasach. Wartość ta nie jest zmienną łańcuchową (String). Najczęściej stosowanymi zmiennymi złożonymi są obiekty i tablice. Typowi Array poświęciliśmy osobny podrozdział. Definicja typu danych Object znajduje się w klasie Object, która jest klasą bazową wszystkich klas w języku ActionScript. Wprawdzie klasa Object sama nie wykonuje wielu działań, jednak jej istnienie jest nieodzowne dla idei programowania obiektowego, jest ona bowiem klasą dynamiczną, co oznacza, że może zostać rozszerzona o nowe właściwości i metody w czasie wykonywania programu. Obiekty bywają także wykorzystywane jako tablice asocjacyjne (tzw. słowniki). Przechowywane w nich wartości stają się dostępne po podaniu odpowiedniego klucza, czyli danych typu łańcuchowego (w zwyczajnych tablicach dostęp do danych uzyskuje się po podaniu indeksu — więcej informacji na ten temat znajdziesz w podrozdziale „Tablice”). Ponieważ w większości omawianych tu przykładów będą pojawiać się zmienne numeryczne i tablice danych, te typy danych omówimy dokładniej.

44

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Numeryczne typy danych W podrozdziale „Zmienne i stałe” wspominaliśmy już o zmiennych typu Number. Do numerycznych typów danych zaliczamy także typy int i uint. Zgodnie ze specyfikacją IEEE 754 dane typu Number to 64-bitowe liczby zmiennoprzecinkowe o podwójnej precyzji. Zmienne tego typu są w stanie przechować liczby rzeczywiste o dodatnich i ujemnych wartościach (to znaczy nie tylko liczby całkowite, lecz także ich ułamki). Największą wartością, jaka może zostać zapisana w zmiennej typu Number, jest 1,8·10308. Biorąc pod uwagę, że liczbę atomów w widocznej części wszechświata szacuje się na „jedyne” 1080, wydaje się, że taki przedział powinien wystarczyć do przeprowadzania nawet największych obliczeń naukowych! Klasa Number zawiera każde trzy wartości specjalne — NaN (z angielskiego not a number — wartość niebędąca liczbą), POSITIVE_INFINITY oraz NEGATIVE_INFINITY. Gdy zmienna typu Number przyjmuje wartość NaN, oznacza to, że nie przypisano jej wartości liczbowej. Ma to miejsce na przykład po zadeklarowaniu zmiennej, a przed zapisaniem w niej liczby. Może się ona także pojawić w wyniku przeprowadzenia na zmiennych operacji niepoprawnej z matematycznego punktu widzenia (na przykład wyciągnięcia pierwiastka kwadratowego z wartości –1 lub podzielenia 0 przez 0). Nieskończoność (wartości POSITIVE_INFINITY lub NEGATIVE_INFINITY) otrzymujemy w wyniku podzielenia dowolnej wartości liczbowej przez 0. O znaku nieskończoności decyduje znak liczby dzielonej przez zero. Dane typu int to opatrzone znakiem 32-bitowe liczby całkowite. Zmienne tego typu mogą przyjmować całkowite wartości dodatnie i ujemne (oraz zerową) z zakresu od –2 147 483 648 do 2 147 483 647. Podobnie definiuje się dane typu uint. Zmiennymi tego typu mogą być wyłącznie całkowite liczby dodatnie oraz 0. Typ uint obejmuje wartości z zakresu od 0 do 4 294 967 295. Jak się zapewne domyślasz, najczęściej stosuje się go do zliczania.

Tablice Tablica jest obiektem przechowującym różnego rodzaju dane. Załóżmy, że chcesz śledzić zachowanie wszystkich cząstek pojawiających się w Twojej animacji. Możesz oczywiście przechowywać te dane w zmiennych oznaczonych odpowiednio particle1, particle2, particle3 i tak dalej. Taki model sprawdzi się, jeżeli cząstek będzie niewiele, ale co zrobić, gdy w animacji pojawi się ich sto czy dziesięć tysięcy? W takich właśnie przypadkach doskonale sprawdzają się tablice. Wystarczy zdefiniować tablicę particles i zapisać w niej dane dotyczące wszystkich cząstek. Najprostszą metodą tworzenia tablicy jest podanie jej elementów w postaci oddzielonej przecinkami listy elementów, zapisanej w nawiasach kwadratowych. var arr:Array = new Array(); arr = [2, 4, 6]; trace(arr[1]); // Zwraca wartość 4.

Na podstawie podanego fragmentu kodu można stwierdzić, że dostęp do wybranego elementu tablicy arr uzyskuje się, podając jej nazwę z tak zwanym indeksem tablicy — arr[n], gdzie n jest odpowiednią liczbą całkowitą dodatnią lub zerem. Zauważ, że elementy tablicy są numerowane od 0, a to oznacza, że odwołaniem do pierwszego elementu będzie arr[0].

45

Rozdział 2.

Oczywiście tablice można tworzyć też w inny sposób. Metody pracy z tablicami i ich elementami są dość skomplikowane i rządzą się ściśle określonymi zasadami. Wkrótce będziesz miał okazję zapoznać się z niektórymi z nich. Tablice mogą mieć więcej niż jeden wymiar. Efekt ten uzyskuje się, definiując tablicę, której elementy są także tablicami. W podanym przykładzie znajduje się kod tworzący dwuwymiarową tablicę z dwóch tablic jednowymiarowych: var xArr:Array = new Array(); var yArr:Array = new Array(); xArr = [1,2]; yArr = [3,4]; var zArr:Array = new Array(xArr,yArr); trace(zArr[0][1]); // Zwraca wartość 2. trace(zArr[1][0]); // Zwraca wartość 3.

Zauważ, że trzecia tablica została utworzona w odmienny sposób niż dwie pierwsze — powstała po przekazaniu wartości elementów bezpośrednio do konstruktora Array(). Tablice w języku ActionScript mogą zawierać elementy różnych typów danych, ponieważ, inaczej niż ma to miejsce w C++ czy Javie, tablice AS nie mają określonego typu. Typ danych Vector (dostępny w wersji Flash 10 i wyższych wersjach tego programu) jest pochodnym tablicy charakteryzującym się określonym typem. Wektory działają zazwyczaj szybciej niż tablice.

Operatory Podstawowe działania arytmetyczne — dodawanie, odejmowanie, mnożenie i dzielenie — realizuje się za pomocą operatorów znanych Ci zapewne z innych języków programowania (+, -, * i /). Język AS3.0 oferuje też kilka innych rzadziej stosowanych operatorów. Operator modulo % zwraca resztę z dzielenia jednej wartości przez drugą, operator inkrementacji (++) zwiększa wartość zmiennej o 1, a operator dekrementacji (--) zmniejsza wartość zmiennej o 1. var x:int = 5; var y:int = 3; trace(x%y); // Zwraca wartość 2. var z:int; z = x++; // Przypisuje zmiennej z wartość x, a następnie zwiększa x o 1. trace(z); // Zwraca wartość 5. z = ++x; // Zwiększa wartość zmiennej z o 1, a następnie przypisuje ją zmiennej z. trace(z); // Zwraca wartość 7.

Operatory działań arytmetycznych można też łączyć z operatorem przypisania, na przykład: var a:int = 1; a = a + 1; trace(a); // Zwraca wartość 2. a += 1; // Skrót zapisu a = a+1. trace(a); // Zwraca wartość 3. a = 4*a; trace(a); // Zwraca wartość 12. a *= 4; // Skrót zapisu a = a*4. trace(a); // Zwraca wartość 48.

46

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Klasa Math Operatory opisane w poprzednim podrozdziale obejmują jedynie podstawowe działania arytmetyczne. Bardziej złożone obliczenia mogą być realizowane za pomocą funkcji klasy Math. Tabela 2.3 zawiera listę najczęściej wykorzystywanych funkcji klasy Math wraz z opisem ich działania. W następnym rozdziale poznasz inne metody tej klasy, między innymi funkcje trygonometryczne, wykładnicze i logarytmiczne. Tabela 2.3. Metody klasy Math

Metoda

Zwracana wartość

Math.abs(a:Number)

Wartość bezwzględna liczby a.

Math.pow(a:Number,b:Number)

Wynik podnoszenia liczby a do potęgi b.

Math.sqrt(a:Number)

Pierwiastek kwadratowy z liczby a.

Math.ceil(a:Number)

Najmniejsza liczba całkowita większa od wartości a.

Math.floor(a:Number)

Największa liczba całkowita mniejsza od wartości a.

Math.round(a:Number)

Liczba całkowita o wartości najbliższej a.

Math.max(a:Number,b:Number,c:Number,…)

Największa liczba ze zbioru a, b, c, …

Math.min(a:Number,b:Number,c:Number,…)

Najmniejsza liczba ze zbioru a, b, c, …

Math.random()

Pseudolosowa liczba n, gdzie 0 ≤ n < 1.

Ostatnia z podanych tu metod, Math.random(), jest dla nas szczególnie interesująca. Zwraca losową liczbę należącą do przedziału od 0 do 1 (bez wartości 1). Dokładnie rzecz biorąc, jest to liczba pseudolosowa, ponieważ wyznaczamy ją na podstawie określonego algorytmu, jednak taka losowość powinna wystarczyć Ci w większości przypadków, z którymi będziesz mieć do czynienia. Opiszemy teraz, w jaki sposób należy stosować metodę Math.random(). Przedstawiony fragment kodu z pliku BouncingBallsRandom.as gwarantuje, że przy każdym uruchomieniu pliku .swf piłka będzie miała inną prędkość początkową. Za tę zmianę odpowiedzialne są dwa wiersze z funkcji init(). vx = Math.random()*5; vy = (Math.random()-0.5)*4;

Instrukcja umieszczona w pierwszej linii sprawia, że pozioma składowa prędkości piłki zawiera się zawsze pomiędzy 0 a 5. Instrukcja z drugiej linii określa wartość pionowej składowej prędkości — jest ona zawsze liczbą z zakresu −2 do 2. Jak należy rozumieć ujemną wartość prędkości pionowej? Jeśli prędkość ciała przyjmuje wartość ujemną, oznacza to, że ciało porusza się w kierunku przeciwnym do przyrostu wartości na osi układu współrzędnych — w naszym przypadku chodzi o oś pionową. W układzie współrzędnych animacji we Flashu wartości osi pionowej rosną wraz z przemieszczaniem się w dół (o układzie współrzędnych we Flashu napiszemy szerzej w dalszej części rozdziału), zatem ujemne wartości pionowej składowej prędkości oznaczają, że ciało porusza się w górę. Dzięki tym dwóm liniom kodu podczas każdego uruchomienia animacji piłka startuje w górę bądź w dół z różnymi (pionową i poziomą) składowymi prędkości.

47

Rozdział 2.

Logika W każdym języku programowania podstawą tworzenia kodu są wyrażenia logiczne. To one pozwalają decydować, który fragment kodu ma zostać wykonany w zależności od zaistniałych warunków. Najprostszym wyrażeniem logicznym, z jakim zetkniesz się w kodach języka ActionScript, jest instrukcja warunkowa if. Jej składnia wygląda następująco: if (warunek logiczny){ Wykonaj ten kod. }

Instrukcja warunkowa sprawdza, czy zdanie logiczne podane w warunku jest prawdziwe. Przykładowo w pliku BouncingBall.as znajduje się następująca instrukcja: if (ball.y > 350){ vy *= -0.8; }

Wyrażenie to sprawdza, czy pionowa współrzędna położenia piłki przekroczyła wartość 350 pikseli. Gdy warunek ten zostanie spełniony, pionowa składowa prędkości piłki zostaje pomnożona przez czynnik −0,8. Instrukcja ta sprawdza prawdziwość wyrażenia ball.y > 350. Pojawiający się w niej znak > to operator logiczny oznaczający „większe niż”. Poza nim w wyrażeniach logicznych pojawiają się także operatory < (mniejsze niż), == (równe), = (większe bądź równe) i != (różne od). Istnieje też operator ścisłego porównania ===, który w czasie sprawdzania warunku logicznego uwzględnia także zgodność typów (czym różni się od operatora ==). Uważaj, by nie mylić operatora porównania (==) z operatorem przypisania (=). To bardzo często popełniany błąd, w dodatku dość trudny do wychwycenia w czasie sprawdzania kodu! Do dyspozycji masz także operatory && (AND) oraz || (OR), które pozwalają łączyć warunki logiczne, na przykład: if (a < 10 || b < 20){ c = a+b; }

Instrukcja warunkowa if pojawia się także w bardziej rozwiniętej postaci, tak zwanej instrukcji if else. if (warunek logiczny){ Jeżeli warunek jest spełniony, wykonaj ten kod. } else { Jeżeli warunek nie jest spełniony, wykonaj ten kod. }

Wyrażenie if … else pozwala realizować różne warianty kodu w zależności od zaistniałych warunków logicznych także w bardziej rozbudowanych przypadkach: if (a == 0){ Jeżeli a jest równe zero, wykonaj ten kod. } else if (a < 0 ) { Jeżeli a ma wartość ujemną, wykonaj ten kod. } else if (a > 0) { Jeżeli a ma wartość dodatnią, wykonaj ten kod.

48

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

} else { Jeżeli a przyjmuje wartość NaN, wykonaj ten kod. }

Do instrukcji logicznych zalicza się także polecenie switch oraz tak zwany operator warunkowy (potrójny), jednak w tej książce raczej nie będziemy z nich korzystać. Oto pierwsze ćwiczenie — zmień kod pliku BouncingBallRandom.as tak, by po zniknięciu z ekranu piłka pojawiała się ponownie w punkcie startowym i rozpoczynała ruch z losowo wybraną prędkością. Poprawny kod znajdziesz w pliku BouncingBallRecycled.as.

Pętle Pętle są kolejnym, po logice, filarem programowania. To właśnie możliwość wielokrotnego powtarzania pewnych operacji (i to bez żadnego znudzenia) w tempie znacznie przewyższającym tempo pracy człowieka sprawia, że komputery są tak przydatne. Tego rodzaju działanie nazywamy zapętlaniem. ActionScript oferuje kilka rodzajów pętli. Poniżej przedstawimy wyłącznie wybrane z nich. Najczęściej będziemy korzystać z pętli for. Oto przykład kodu pozwalającego dodać do siebie sto pierwszych liczb naturalnych: var sum:Number = 0; for (var i:int = 1; i 200){ ball.z = 200;

55

Rozdział 2.

vz *= wfac; } if (ball.z < -200){ ball.z = -200; vz *= wfac; } }

Pełny kod aplikacji znajdziesz w pliku BouncingBall3D.as. Uruchom animację, a przekonasz się, że wygląda ona tak, jakby piłka odbijała się wewnątrz niewidzialnego trójwymiarowego pudełka! O to, by ścianki pudełka stały się widoczne, zadbamy już wkrótce.

Graficzny interfejs programowania Flasha Graficzny interfejs programowania aplikacji (API) Flasha pozwala rysować podstawowe kształty i nadawać im wypełnienie bezpośrednio z poziomu ActionScriptu. Jest to możliwe, ponieważ wszystkie obiekty w ActionScripcie dysponują właściwością graphics mającą dostęp do wszystkich metod graficznych występujących w API.

Rysowanie prostych i krzywych Aby narysować prostą bądź dowolną krzywą, musisz nauczyć się pracy z czterema metodami API — lineStyle, moveTo, lineTo i curveTo. ƒ

Metoda lineStyle(width, color, alpha) przyjmuje trzy argumenty — pierwszy z nich określa szerokość rysowanej linii, drugi jej kolor, a trzeci stopień przezroczystości.

ƒ

Metoda moveTo(x, y) przesuwa kursor do punktu o współrzędnych x i y, nie rysując przy tym linii.

ƒ

Metoda lineTo(x, y) rysuje prostą łączącą punkt, w którym znajduje się kursor, z punktem o współrzędnych x i y.

ƒ

Metoda curveTo(x1, y1, x2, y2) łączy bieżące położenie kursora z punktem o współrzędnej (x2, y2) krzywą o promieniu krzywizny zadanym punktem kontrolnym (x1, y1).

Na przykład aby narysować linię prostą łączącą punkty o współrzędnych (50, 100) i (250, 400), należałoby wprowadzić do programu następujący kod: graphics.lineStyle(1,0x000000,1); graphics.moveTo(50, 100); graphics.lineTo(250, 400);

W ramach ćwiczenia możesz spróbować narysować za pomocą tych poleceń siatkę wykresu. Odpowiedni kod podaliśmy w pliku Grid.as. Kilka prostych metod pozwala bez trudu rysować kształty podstawowe — koła czy prostokąty. Metoda drawCircle(x, y, radius) dodaje do sceny okrąg o środku w punkcie (x, y) i podanym promieniu, metoda drawRect(x, y, width, height) rysuje prostokąt o zadanej szerokości i wysokości, którego lewy górny róg przypada w punkcie o współrzędnych (x, y).

56

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Wypełnienia i gradienty Wypełnianie narysowanych kształtów nie wymaga wielkich starań. Metoda beginFill(color, alpha) pozwala określić kolor i stopień przezroczystości wypełnienia wszystkich kształtów rysowanych do chwili uruchomienia metody endFill(). Podany poniżej kod pozwala narysować zielony, nieobramowany prostokąt: graphics.lineStyle(1,0x000000,0); graphics.beginFill(0x00ff00); graphics.drawRect(10, 10, 20, 30); graphics.endFill();

Uzyskanie wypełnienia gradientowego wymaga nieco większych starań. Stosowana w tym celu metoda beginGradientFill() przyjmuje aż osiem argumentów. Niektóre z nich mają zdefiniowane wartości domyślne, więc nie zawsze trzeba podawać je jawnie. ƒ

Argument type:String określa, jakiego rodzaju wypełnienie gradientowe ma zostać użyte. Przyjmuje on jedną z dwóch wartości — GradientType.LINEAR lub GradientType.RADIAL.

ƒ

Argument colors:Array pozwala wprowadzić do funkcji tablicę kolorów schematu RGB zapisanych w systemie szesnastkowym, które zostaną wykorzystane do utworzenia gradientu.

ƒ

Argument alphas:Array przekazuje do metody tablicę wartości poziomów przezroczystości definiowanych dla każdego z kolorów tablicy colors. Elementy tablicy alphas mogą przyjmować wartości z zakresu od 0 do 1.

ƒ

Argument ratios:Array wprowadza do funkcji tablicę określającą położenie najintensywniejszego odcienia w gradiencie. Elementy tablicy przyjmują wartości z zakresu od 0 do 255.

ƒ

Argument matrix:Matrix (default = null) to tablica transformująca, która pozwala określić sposób wypełnienia kształtu.

ƒ

Argument spreadMethod:String (default = "pad") to wartość określająca, w jaki sposób gradient ma rozlać się po kształcie. Użytkownik może wybrać jedno z dopuszczalnych ustawień SpreadMethod.PAD (wypełnienie), SpreadMethod.REFLECT (odbicie) bądź SpreadMethod.REPEAT (powtórzenie).

ƒ

Argument interpolationMethod:String (default = "rgb") pozwala wskazać metodę interpolacji. Dopuszczalne wartości to InterpolationMethod.LINEAR_RGB i InterpolationMethod.RGB.

ƒ

Argument focalPointRatio:Number (default = 0) daje kontrolę nad położeniem ogniskowej gradientu. Może przyjmować wartości z przedziału −1 do 1.

Prawdopodobnie w większości przypadków ograniczysz się do określania wartości pierwszych pięciu argumentów metody beginGradientFill(). Cztery ostatnie zmienne, które można do niej wprowadzić, mają zdefiniowane wartości domyślne, zatem podczas wywoływania można w ogóle pominąć ich podawanie. Nie będziemy tu opisywać możliwości, jakie daje modyfikowanie każdego z argumentów metody beginGradient ´Fill(), ponieważ materiał ten wykracza zdecydowanie poza zakres poruszanych tu zagadnień. Jeśli interesują Cię szczegóły, możesz zapoznać się z odpowiednimi opisami umieszczonymi na stronach serwisu http://help.adobe.com/pl_PL/FlashPlatform/reference/actionscript/3/index.html. W rozdziale 1. przedstawiliśmy kod klasy Ball (na razie nie omówiliśmy go dokładniej) umieszczonej w pliku BouncingBall.as, której zadaniem jest utworzenie obiektu piłki. Po zapoznaniu się z zawartością tego podrozdziału nie powinieneś mieć większych problemów z samodzielnym przeanalizowaniem kodu wspomnianej klasy. To, co może przysporzyć nieco trudności, to zrozumienie trzech wierszy odpowiedzialnych za utworzenie wypełnienia gradientowego.

57

Rozdział 2.

var matrix:Matrix = new Matrix(); matrix.createGradientBox(_radius,_radius,0,-_radius,-_radius/2); graphics.beginGradientFill(GradientType.RADIAL,[0xffffff,_color],[1,1],[0,255],matrix);

Wyjaśnijmy zatem. Po powołaniu do życia obiektu matrix wywołaliśmy metodę CreateGradientBox() z pięcioma argumentami — szerokością, wysokością, obrotem oraz parametrami przesunięcia w poziomie i w pionie. Wartości zostały dobrane odpowiednio do promienia kulki, tak by efekt ostateczny wyglądał ładnie — nie wahaj się przeprowadzić testów dla innych wartości. Ostatni wiersz przytoczonego tu fragmentu kodu to wywołanie metody graphics.beginGradientFill(), która wypełnia obiekt gradientowym przejściem pomiędzy dwoma kolorami (z których jeden to biały). Stopień przezroczystości każdego z nich określiliśmy na 1, a najintensywniejsze odcienie każdej z barw umieściliśmy w skrajnych położeniach — 0 i 255. Ostatnim parametrem metody jest utworzona wcześniej macierz pozwalająca wypełnić kształt gradientem.

Przykład — piłka wewnątrz pudełka Nadeszła pora, by wykorzystać w praktyce wszystko to, czego dowiedziałeś się z ostatnich dwóch podrozdziałów (dotyczących grafiki trójwymiarowej we Flashu i stosowania interfejsu graficznego). Zajmiemy się teraz tworzeniem animacji kulki odbijającej się wewnątrz pudełka! Poniżej znajdziesz kod zawarty w pliku BouncingBall3DWalls.ad, a na rysunku 2.4 możesz zobaczyć końcowy efekt uruchomienia animacji. package { import flash.display.Sprite; import flash.events.Event; public class BouncingBall3DWalls extends Sprite { private var g:Number=0.1; // przyśpieszenie grawitacyjne private var vx:Number; // prędkość początkowa w poziomie private var vy:Number; // prędkość początkowa w pionie private var vz:Number; // prędkość boczna private var ball:Ball; private var w:Number; private var gfac:Number=-0.99; private var wfac:Number=-0.99; public function BouncingBall3DWalls() { init(); } private function init():void { setWall(0,200,250,300,400,-90); // lewa ściana setWall(550,200,250,300,400,90); // prawa ściana setWall(275,200,400,548,400,0); // tylna ściana vx = Math.random()*5; vy = (Math.random()-0.5)*4; vz = 4; ball = new Ball(); ball.x = 100; ball.y = 75; ball.z = 0; w = ball.width/2; addChild(ball); addEventListener(Event.ENTER_FRAME,onEachTimestep);

58

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

setWall(275,200,100,550,400,0,0x0000ff,0.2); // przednia ściana } private function setWall(pX:Number, pY:Number, pZ:Number, pW:Number, pH:Number, pAngle:Number, pCol:uint=0x586cbf, pAlp:Number=1):void{ var wall:Wall = new Wall(pW, pH, pCol, pAlp); wall.x=pX; wall.y=pY; wall.z=pZ; wall.rotationY=pAngle; addChild(wall); } private function vy += g; ball.x += vx; ball.y += vy; ball.z += vz;

onEachTimestep(evt:Event):void{ // Grawitacja wywołuje wzrost pionowej składowej prędkości piłki. // Pozioma składowa prędkości sprawia, że pozioma współrzędna położenia rośnie. // Pionowa składowa prędkości sprawia, że pionowa współrzędna położenia rośnie.

if (ball.y > 350){ // Po uderzeniu o ziemię ball.y = 350; vy *= gfac; // pionowa składowa prędkości zmienia zwrot, a jej wartość maleje. } if (ball.x > 550 - w){ ball.x = 550 - w; vx *= wfac; } if (ball.x < w){ ball.x = w; vx *= wfac; } if (ball.z > 400){ ball.z = 400; vz *= wfac; } if (ball.z < 100){ ball.z = 100; vz *= wfac; } } } }

Oto co zrobiliśmy. Zaczęliśmy od utworzenia klasy Wall. Zajrzyj do pliku Wall.as, a przekonasz się, że jej kod jest bardzo prosty. Przekazaliśmy do konstruktora określone wartości szerokości, wysokości, koloru i przezroczystości. Następnie w kodzie głównym BouncingBallBox zdefiniowaliśmy funkcję setWall(), której zadaniem jest utworzyć obiekty ścian, ustawić je i obrócić w trójwymiarowej przestrzeni. Funkcja ta przyjmuje osiem argumentów, przy czym podanie ostatnich dwóch (koloru i parametru alfa) jest opcjonalne. Pozostałych sześć określa położenie ściany i jej ustawienie w przestrzeni. Ostatnim etapem pracy było czterokrotne wywołanie funkcji setWall() wewnątrz funkcji init(), by zbudować cztery ściany pudełka. Zwróć uwagę na to, że trzy z czterech ścian są tworzone przed umieszczeniem na

59

Rozdział 2.

Rysunek 2.4. Piłka odbijająca się wewnątrz pudełka

scenie piłki, natomiast czwarta (najbliższa powierzchni ekranu) pojawia się na scenie po utworzeniu piłki. Takie działanie jest wymuszone brakiem automatycznego sortowania głębi w animacjach trójwymiarowych Flash — parametr głębi jest określany na podstawie kolejności umieszczania obiektów na scenie. Aby odtworzyć animację, będziesz potrzebować programu Adobe Flash Player w wersji 10 lub wyższej, natomiast żeby pracować z jej kodem źródłowym, musisz zainstalować Flash CS4 lub nowszy.

Tworzenie animacji za pomocą kodu Istnieją różne sposoby wykonania animacji za pomocą kodu AS3.0, choćby wykorzystanie klasy Tween, która przesuwa elementy, zmienia ich rozmiar i pozwala ściemniać scenę. My jednak chcemy skupić się na tworzeniu animacji możliwie realistycznych z perspektywy fizyki. Wiemy mniej więcej, w jaki sposób przesuwać obiekty po scenie, potrzebujemy zatem metody odmierzania czasu wewnątrz animacji, innymi słowy, musimy sprawić sobie zegar.

Wbudowane odliczanie klatek w roli zegara Do tej pory jako zegara używaliśmy zdarzenia ENTER_FRAME. Pora sprawdzić, czy dobrze wywiązuje się ono z powierzonej mu roli. Załóżmy dla przykładu, że klatki animacji przesuwają się z prędkością pięćdziesięciu na sekundę. Teoretycznie oznacza to, że zdarzenie Event.ENTER_FRAME występuje z częstotliwością jednej pięćdziesiątej sekundy (co dwadzieścia milisekund). Teoretycznie, ponieważ jak się okazuje, ustalanie liczby klatek na sekundę w programie Flash Player jest mechanizmem bardzo nieprecyzyjnym, zależnym między innymi od komputera, na jakim uruchamiamy animację. Jaki efekt wywiera to na wynik końcowy naszej pracy?

60

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Aby odpowiedzieć na to pytanie, będziemy musieli przeprowadzić pewne nieskomplikowane obliczenia matematyczne. Załóżmy, że chcemy przesuwać dany obiekt ze stałą prędkością stu pikseli na sekundę, przyjmijmy też, że liczba klatek na sekundę w animacji wynosi 50. Zwiększamy zatem poziome położenie ciała o parametr vx w każdej nowej klatce, jak miało to miejsce w omówionym już przykładzie odbijającej się piłki. private function onEachTimestep(evt:Event):void{ ball.x += vx; }

Oznacza to, że vx jest poziomą składową prędkości ciała wyrażaną w pikselach na klatkę. Zatem jaką wartość należy przypisać zmiennej vx? Skoro prędkość wyrażana w pikselach na sekundę ma wynosić 100, a liczba klatek wyświetlanych w ciągu jednej sekundy wynosi 50, to vx powinno wynosić 100/50, czyli 2. Ogólnie można zapisać następującą zależność: (Prędkość wyrażana liczbą pikseli na sekundę) = (Prędkość wyrażana liczbą pikseli na klatkę)·(Liczba klatek na sekundę). Oznacza to, że po ustaleniu wartości zmiennej vx na 2 powinniśmy zobaczyć animację, w której piłka będzie się przesuwać po scenie z prędkością 100 px/s. Niestety nie ma żadnej gwarancji, że animacja będzie wyświetlana w takim samym tempie, jakie zadaliśmy w kodzie. Jeżeli Twój komputer jest nieco wolniejszy bądź uruchomiłeś na nim kilka innych aplikacji, tempo wyświetlania klatek na sekundę może spaść nawet do 30. W takim przypadku piłka będzie poruszać się po scenie z prędkością wynoszącą jedynie 60 px/s, czyli znacznie wolniej, niż zakładałeś. Ponadto jeżeli kiedyś zdecydujesz się wykonać animację w innym tempie, prędkość piłki również się zmieni. Rozważania te prowadzą do jednego wniosku — potrzebujemy innego sposobu mierzenia czasu, zegara, który nie będzie polegać na tempie, w jakim wyświetlana jest animacja.

Praca z klasą Timer Uznaliśmy, że zdarzenie Event.ENTER_FRAME jest zbyt niedokładne, by powierzać mu zadanie odmierzania czasu w aplikacji. Czy mamy jakieś inne wyjście? Tak, możemy na przykład skorzystać z klasy Timer (zawartej w pakiecie flash.utils) oraz stowarzyszonej z nią klasy TimeEvent (z pakietu flash.events). Działanie klasy Timer nie różni się wiele od sposobu funkcjonowania Event.ENTER_FRAME — wywołuje ona pewne zdarzenie z określoną częstotliwością, ale można na niej polegać w znacznie większym stopniu niż na Event.ENTER_FRAME. Aby uruchomić zegar działający na bazie klasy Timer, należy najpierw utworzyć odpowiedni obiekt: timer = new Timer(10, 1000);

Instancje klasy Timer() są powoływane z dwoma argumentami. Pierwszym z nich jest podawany w milisekundach czas, po jakim mają następować kolejne uruchomienia zdarzenia, drugim, dowolnym, jest liczba kolejnych uruchomień zdarzenia. Jeśli nie zdefiniujesz drugiego argumentu bądź nadasz mu wartość 0, zdarzenie będzie uruchamiane w nieskończoność. Następnie należy uruchomić procedurę wychwytującą nastąpienie zdarzenia: timer.addEventListener(TimerEvent.TIMER, onEachTimestep);

oraz zbudować procedurę, która zareaguje na to zdarzenie:

61

Rozdział 2.

private function onEachTimestep(evt:TimerEvent):void{ ball.x + = vx; }

Teraz należy zadbać o to, by uruchomić obsługę zdarzenia! To właśnie różni nasz nowy zegar od stosowanego poprzednio — obiekty klasy Timer nie pojawiają się same z siebie, nie odmierzają też automatycznie czasu. Dlatego po utworzeniu nowej instancji klasy musisz jeszcze ją uruchomić za pomocą metody start(): timer.start();

Oczywiście uruchomiony w ten sposób zegar możesz także zatrzymać w dowolnej chwili: timer.stop();

To bardzo przydatne rozwiązanie, ponieważ pozwala zatrzymywać animację i uruchamiać ją ponownie w dowolnej chwili bez konieczności usuwania procedury wychwytującej zdarzenie i ponownego jej uruchamiania (co nie jest zbyt eleganckim rozwiązaniem). Musisz też pamiętać, że tak zbudowany zegar nie zadba o odświeżenie zawartości ekranu, jeśli więc zdecydujesz się wyświetlać animację w tempie wolniejszym niż kolejne tyknięcia licznika, położenie obiektów nie zmieni się do wystąpienia kolejnego zdarzenia odświeżającego klatkę. Jeżeli opóźnienie licznika wynosi 10 milisekund, a animacja jest wyświetlana z częstotliwością odświeżania 10 klatek na sekundę, to układ sceny będzie zmieniać się co 0,1 sekundy czy też 100 milisekund, czyli dla co dziesiątego „tyknięcia” zegara. W efekcie pomimo wysokiej częstotliwości wykonywania obliczeń nowego położenia ciała cała animacja będzie sprawiać wrażenie szarpania. Aby temu zaradzić, należy wymusić odświeżanie ekranu po każdym „tyknięciu” zegara. W tym celu skorzystamy z metody updateAfterEvent(): private function onEachTimestep(evt:TimerEvent):void{ ball.x + = vx; evt.updateAfterEvent(); }

Choć działanie zegara pracującego na bazie klasy Timer jest znaczącym krokiem naprzód w stosunku do Event.ENTER_FRAME, rozwiązanie to nie jest pozbawione wad. Jednym z zasadniczych problemów tego rozwiązania jest to, że czas oddzielający kolejne „tyknięcia” zaczyna być mierzony z chwilą wykonania kodu zawartego w procedurze obsługującej zdarzenie. Jeśli kod jest rozbudowany, jego wykonywanie może znacząco opóźnić działanie zegara.

Wyznaczanie upływu czasu za pomocą funkcji getTimer() Kiepskie metody pomiaru czasu mogą zepsuć cały efekt animacji. Aby móc dokonywać precyzyjnych obliczeń, musimy wiedzieć, ile dokładnie czasu upłynęło pomiędzy dwoma wybranymi momentami trwania programu. Keith Peters w Foundation ActionScript Animation podaje doskonały sposób odmierzania czasu — zaleca odwołanie się do funkcji getTimer(). Znajdująca się w pakiecie flash.utils funkcja getTimer() zwraca liczbę całkowitą równą liczbie milisekund, jakie upłynęły od chwili uruchomienia programu Flash Player. Jeśli zatem wywołasz ją dwukrotnie, za każdym razem w innej części kodu, i obliczysz różnicę otrzymanych wartości, wyznaczysz w ten sposób czas, jaki upłynął pomiędzy obydwoma wywołaniami. Jak możemy to wykorzystać? Dzięki temu rozwiązaniu zdołamy obliczyć, ile czasu upłynęło od ostatniej aktualizacji położenia obiektu na scenie. Na podstawie tej wartości wyznaczymy zmianę położenia ciała.

62

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Kod przykładowej animacji przedstawiającej kulkę poruszającą się w poziomie ze stałą prędkością znajduje się w pliku TimerExample.as. Oto jak zmienił się kod procedury obsługującej zdarzenie: private function onEachTimestep(evt:TimerEvent):void{ // Czas (w milisekundach), jaki upłynął od poprzedniego wywołania.

var dt:Number = (getTimer() - t)/1000; t = getTimer(); // Ponowne przypisanie wartości zmiennej t. ball.x += vx*dt; evt.updateAfterEvent(); }

W procedurze pojawiły się dwie nowe linie kodu. Pierwsza z nich określa czas, jaki upłynął od poprzedniego wywołania procedury onEachTimestep() — jest on zapisywany w zmiennej dt (w następnym rozdziale wyjaśnimy, skąd takie oznaczenie). Pojawiająca się w niej prywatna zmienna t przechowuje wartość dostarczoną przez funkcję getTimer() pobraną przed rozpoczęciem animacji. W następnej linii zmiennej przypisujemy nową wartość, która zostanie użyta przy ponownym wywołaniu procedury. Jeśli przyjrzysz się zawartości pliku, zauważysz też, że zmieniliśmy kod, który odpowiada za aktualizowanie położenia piłki. Zamiast dodawać do współrzędnej x wartość zmiennej vx, dodajemy do niej wynik mnożenia vx*dt. Dlaczego w ten sposób? Cóż, właśnie po to zadawaliśmy sobie tyle trudu z wyznaczaniem wartości przyrostu czasu dt. Poprzednio definiowaliśmy prędkość jako liczbę pikseli, o które przesunęła się piłka w czasie potrzebnym na wyświetlenie jednej klatki animacji (rozwiązanie bazujące na Event.ENTER_FRAME) w czasie trwania jednego „tyknięcia” (rozwiązanie bazujące na klasie Timer). Zakładaliśmy przy tym, że klatki zmieniają się ze stałą częstotliwością bądź w taki właśnie sposób tyka nasz zegar, przyjmowaliśmy także, że częstotliwość ta jest równa zadanej odpowiednim parametrem w kodzie. Dopóki rzeczywistość nie przeczyła tym założeniom, częstotliwość zmiany klatek animacji lub tyknięć zegara była dobrym przybliżeniem pomiaru czasu. W takich warunkach nic nie stało na przeszkodzie, by podawać prędkość poruszającej się piłki w liczbie pikseli, jakie przebyła ona w czasie wyświetlania jednej klatki animacji czy w czasie odpowiadającym jednemu tyknięciu. Teraz jednak proponujemy powrócić do poprawnego definiowania prędkości — podawania jej jako liczby pikseli pokonywanych przez ciało w ciągu jednej sekundy. Oznacza to, że w czasie równym dt piłka pokonuje odległość równą vx*dt, zatem jej nowe położenie po każdym kroku obliczeń wyznacza się ze wzoru: ball.x += vx*dt;

Powrót do rzeczywistej definicji prędkości ma zasadniczą zaletę — pozwala zawsze wyznaczać położenie ciała poprawnie, w sposób niezależny od częstotliwości odświeżania obrazu czy tyknięć prowizorycznego zegara. Proponowane tu rozwiązanie przyda się nam niejednokrotnie, gdy zaczniemy zajmować się bardziej złożonymi problemami fizycznymi. Oto cały kod zawarty w pliku TimerExample.as: package { import import import import

flash.display.Sprite; flash.utils.Timer; flash.events.TimerEvent; flash.utils.getTimer;

public class TimerExample extends Sprite { private var vx:Number=100; // Prędkość w pikselach na sekundę. private var ball:Ball; private var timer:Timer;

63

Rozdział 2.

private var t:int; public function TimerExample() { init(); } private function init():void { createBall(); setupTimer(); } private function createBall():void{ ball = new Ball(); ball.x = 50; ball.y = 100; addChild(ball); } private function setupTimer():void{ timer = new Timer(20); timer.addEventListener(TimerEvent.TIMER,onEachTimestep); timer.start(); t = getTimer(); // Inicjowanie wartości t. } private function onEachTimestep(evt:TimerEvent):void{ // Czas (w milisekundach), jaki upłynął od poprzedniego wywołania.

var dt:Number = (getTimer() - t)/1000; t = getTimer(); // Ponowne przypisanie wartości zmiennej t. ball.x += vx*dt; evt.updateAfterEvent(); } } }

Przygotowywanie danych do wykonania animacji Jak zapewne zauważyłeś, wszystkich obliczeń potrzebnych do wykonania animacji dokonujemy „w locie”. Można oczywiście przeprowadzić je wcześniej i dopiero mając przygotowany zestaw danych, przygotować animację. W tym celu wykorzystuje się zazwyczaj pętlę for lub while, gdzie każda iteracja odpowiada nowej chwili w przebiegu zjawiska. W każdym kroku oblicza się wtedy nowe położenie ciała, a wyniki zapisuje się w tablicy. Następnie można eksportować je do zewnętrznego pliku (jeśli korzystasz z Adobe AIR) i użyć w innej animacji. Dlaczego stosuje się takie rozwiązania? Czasami obliczenia pochłaniają po prostu zbyt wiele czasu, by zapewnić rozsądną częstotliwość odświeżania obrazu. Niewątpliwą wadą tej metody jest niemożność wprowadzenia do animacji jakichkolwiek elementów interaktywnych. Ponieważ prowadzenie interakcji z aplikacją jest jednym z kluczowych elementów symulacji fizycznych, nie zrezygnujemy z animowania zjawisk w czasie rzeczywistym.

64

Programowanie w języku ActionScript 3.0 — wybrane zagadnienia

Wykrywanie zderzeń Zderzenia są częścią animowanego świata. Jak dotąd nie zastanawialiśmy się, w jaki sposób zmusić animowane obiekty do „zauważania” swojej obecności na scenie. W tym podrozdziale zajmiemy się pierwszym etapem pracy nad zderzeniami w animacjach — wykrywaniem ich zajścia. O zachowaniu się ciała w czasie zderzenia napiszemy szerzej w rozdziale 11. Tworzenie procedur odpowiedzialnych za wykrywanie zderzeń nie zalicza się do zadań prostych, ale jeśli obiekty mają prostokątny kształt, można skorzystać z wbudowanej metody hitTestObject().

Praca z metodą hitTestObject() Metoda hitTestObject() pozwala stwierdzić, czy doszło do zderzenia dwóch obiektów odpowiedzialnych za wyświetlanie (na przykład obiektów klasy Sprite czy MovieClip). object1.hitTestObject(object2);

Zwraca ona wynik typu Boolean — wartość true, jeśli doszło do zderzenia, lub wartość false, jeśli do niego nie doszło — dlatego zazwyczaj używa się jej jako warunku testującego w instrukcji if. Gdy warunek jest spełniony, instrukcja wykonuje kod obsługujący zderzenie. Jak to działa? Metoda hitTestObject() sprawdza, czy ramki ograniczające dwa wyświetlane obiekty zachodzą na siebie, czy nie. Jeśli obiekty są prostokątne, ramki pokrywają się z ich kształtami, więc hitTestObject() działa doskonale. Niestety gdy choć jeden z obiektów ma inny kształt (na przykład jest okręgiem), otaczająca go ramka wychodzi poza wyświetlaną powierzchnię obiektu, przez co metoda hitTestObject() zwraca wartość true również w przypadkach, gdy obiekty nie stykają się ze sobą.

Praca z metodą hitTestPoint() Metoda hitTestPoint() sprawdza, czy wskazany punkt styka się z wyświetlanym na scenie obiektem. Metoda przyjmuje dwa argumenty, które musisz podać, uzupełnione ewentualnie parametrem opcjonalnym, a zwraca wynik będący wartością typu Boolean. object.hitTestPoint(x:Number, y:Number, shapeFlag:Boolean = false);

Pierwsze dwa parametry określają współrzędne punktu, dla którego ma być przeprowadzany test, ostatni — shapeFlag — informuje, czy test ma zostać przeprowadzony dla wyświetlanego kształtu (wtedy argument powinien przyjąć wartość true), czy też dla ramki go ograniczającej (domyślna wartość false). Po przypisaniu zmiennej shapeFlag wartości true metoda ta pozwala nad wyraz skutecznie wykrywać zderzenia w przypadkach, gdy dochodzi do zderzenia niewielkiego obiektu (na przykład pocisku) z dużym obiektem o skomplikowanym kształcie (na przykład ze statkiem kosmicznym) — wtedy BUM!

Wykrywanie zderzeń na podstawie wyznaczania odległości Metoda ta zakłada wykrywanie zderzeń pomiędzy ciałami poprzez bezpośrednie wyznaczenie dzielącej je odległości. Sprawdza się ona najlepiej dla obiektów okrągłych. Jej odmianę stosowaliśmy, sprawdzając, czy odbijająca się piłka nie trafiła na podłoże lub ściany. Rozwiązanie to polega na wyznaczeniu minimalnej

65

Rozdział 2.

odległości, w jakiej mogą znaleźć się dwa ciała, zanim dojdzie do zetknięcia się ich powierzchni. Załóżmy, że na scenie znajduje się okrągła piłka z punktem odniesienia (ang. registration point) umiejscowionym w jej środku. Oznacza to, że najmniejszą odległością, na jaką piłka może zbliżyć się do ściany, jest promień piłki. Oto jak powinien wyglądać warunek sprawdzający, czy piłka uderza w znajdującą się po prawej stronie sceny ścianę (_wallx to położenie ściany, a _radius to promień piłki): if (ball.x >= _wallx - _radius){ Kod procedury zderzenia. }

Do zderzenia pomiędzy dwoma okręgami o promieniach r1 i r2 dochodzi, gdy odległość dzieląca ich środki osiąga wartość r1+r2. Dlaczego? Ponieważ w takiej odległości od siebie znajdują się środki kul bądź okręgów stykających się powierzchniami. Pozostaje zatem odpowiedzieć na pytanie, w jaki sposób obliczyć odległość dzielącą środki kół. Musimy odwołać się do jednego z podstawowych zagadnień geometrii — problemu wyznaczania odległości pomiędzy dwoma punktami. Na szczęście odpowiedni wzór opracował grecki uczony, Pitagoras. Tak, chodzi oczywiście o twierdzenie Pitagorasa. Szczegółowo przyjrzymy się mu w następnym rozdziale, teraz wystarczy, jeśli poznasz sam wzór: dist = Math.sqrt((x2 – x1)* (x2 – x1) + (y2 – y1)* (y2 – y1));

Równanie to pozwala obliczyć odległość dzielącą punkty o współrzędnych (x1, y1) i (x2, y2) — w tym celu należy wyznaczyć pierwiastek kwadratowy z sumy kwadratów różnic współrzędnych x i y obydwu punktów. Pamiętajmy, że nasze rozważania dotyczą dwóch okręgów, zatem punkty ( x1, y1) i (x2, y2) będą w rzeczywistości środkami tych okręgów. Jeżeli punkty odniesienia okręgów umieszczone są w ich środkach, wspomniane przed chwilą współrzędne będą równe po prostu właściwościom x i y tych obiektów we Flashu. Ostatecznie warunek wykrywania zderzenia będzie miał następującą postać: if (dist