THOMAS Lively: Rendben.
Sziasztok.
Én vagyok Thomas Lively.
A szeminárium lesz írásban 2D játékok C-SDL.
Szóval tudom, hogy minden kérve, igen, én tényleg
akar játszani, és játékok, De mi is ez az SDL üzlet?
Tehát SDL egy C könyvtár.
Ez áll az egyszerű DirectMedia réteg.
És ez egy több platformon, játékfejlesztés könyvtár.
Úgy működik, a Windows, Mac, Linux, sőt iOS és az Android.
Ez kezeli a dolgokat, mint hozzáférést biztosít az audio rendszerek
A számítógép, a billentyűzet, és a egér, joystick, ha ők csatolták.
A mobil, akkor is ezt a touch beviteli és minden adott.
És persze, hogy kezeli a grafika, rajz dolgokat a képernyőn.
>> Így nagyon széles körben használják, annak ellenére, lehet, hogy nem is hallottak róla korábban.
Ez beépítve, például, Valve Source Engine,
amely hatáskört játékok, mint a Portal és a Team Fortress 2.
Ez is egy nagyon nagy szám Az indie játékok jönnek ki,
így izgatott vagyok, hogy mit minden lesz így vele.
>> A szeminárium célja az, hogy neked tűzte ki, hogy legyen a fejlődő SDL.
Fogunk tanulni, hogyan hogy hozzon létre egy játék ablakot.
Fogunk létrehozni sprite, amelyek a képek a játék
hogy lehet mozogni.
Fogunk tanulni, hogyan és animálni a sprite,
így mozgatni őket körül, hogy ezek időről időre változnak.
És fogunk tanulni, hogyan megragadni billentyűzet és egér
bemenet a számítógépet.
Mi nem fogunk beszélni a mai 3D-s grafika,
mert ez egy nagyon bonyolult tárgya, hogy nem volt ideje.
Nem fogjuk tanulni, hogyan kell hangfájlok lejátszására a játékunk.
És nem fogunk épület semmit, de a Linux.
>> Most a kifogások vannak, hogy Remélhetőleg végére a szeminárium,
akkor kényelmes, Az SDL dokumentációt,
így képes lesz arra, hogy menjen kitaláljuk hogyan kell játszani audio magad.
Szintén az épület Mac vagy PC működnie kell pontosan ugyanaz, mint az épület Linux,
de a telepítő fog egy kicsit más.
Tehát meg kell tenni, hogy kitaláljuk hogyan kell csinálni ezeket a dolgokat
végére a mai szemináriumon.
>> Tehát a felállás, megyünk hogy egy virtuális gép.
Mi is használja a CS50 IDE, mert mi csak lesz írásban C.
De mivel az IDE nem a böngésző, akkor Nem hozhat létre új ablakokat, vagy kijelző
kép, grafika.
Tehát szükségünk van egy virtuális gép.
Szóval lehet követni az utasításokat itt manual.CS50.net/appliance/15
telepíteni a hivatalos CS50 készüléket, amely csupán a Linux virtuális
gép.
>> És akkor, ha már hogy minden beállított up-- meg
Lehet, hogy egy kis időre, mert egy nagyon nagy download-- fogsz
fut a VM sudo apt-get update.
És ez folyik valójában frissíteni az összes szoftver
csomagokat a virtuális gép.
>> Ezután, meg fogsz futni sudo apt-get install, libsdl2-2.0-0,
libsdl2-dbg, libsdl2-dev, és emellett libsdl2-image-2,0-0,
libsdl2-image-dbg, és libsdl2-image-dev.
Tehát mit tegyek?
Ezzel ugyanis telepíti a hibakeresés információt, dokumentációt, fejlécek,
és bináris fájlok két könyvtárban.
Rendszeres régi, SDL 2.0, és egy másik könyvtárba
nevű SDL kép, amely fogunk használni
betölteni a képfájlokat a játékunkat.
>> Tehát ha egyszer már, hogy is hogy éppen akkor, amikor azt kérdezi,
csak írja igen, az Enter leütése telepíteni ezeket a csomagokat,
és akkor jó lesz menni.
Tehát, hogy a forgalmazási kódot, can-- ó drága, ez nem frissül.
Kivéve, ha van egy GitHub account-- ha van egy GitHub véve,
akkor ezt Git klón parancsot a repo
és hogy letölti a Git repo az összes kódot is,
így neked kell a kódot.
>> Ha nincs GitHub véve, mit kell tennie, hogy írja
wgithttps: //github.com/tlively/sdl seminar-- és itt ez different--
/archive/master.zip.
Tehát újra, ez pontosan ugyanaz a URL, kivéve, hogy lesz
tlively / SDL_seminar / master.zip és Ön használ wgit letölteni ezt.
És akkor csak csomagold ki, hogy archív
és akkor lesz a teljes forráskódot.
Annyira sajnálom.
És akkor a kód is házigazdája A CS50 szeminárium honlapján egy pár
nap.
>> Minden rendben.
Szóval hogyan lehet elkezdeni írásban a saját játékát?
Nos, az első dolog, fogunk akarok
van nézd meg az SDL dokumentációt.
Tehát itt a VM.
És itt van a weboldalt.
Már navigált élni libsdl.org.
Mit fogok csinálni itt megy át a tálaló mellett dokumentációt,
és kattintson a wiki.
Ez hozza meg, hogy a wiki, hogy van a legtöbb a dokumentáció SDL.
Több mint a tálaló itt vagyunk fog kattintson API kategória,
mert fog adni nekünk egy szép kilátás kategorikus
A teljes API SDL.
>> Így például, hogy van Az alap indítása
és állítsa le az összes fajta igazgatási cucc SDL-t használó,
és akkor mi van a szakaszt megjelenítésére dolgokat a képernyőn.
Ez a videó.
Bemeneti eseményeket, ez egyre közreműködött a billentyűzet,
egyre bemenet a képre, és A joystick, ha van még.
Van force feedback a dolgokat mint a játékvezérlők, amely
nem fogunk beszélni.
És itt van hang.
És akkor ott van egy csomó más cucc, ami SDL tehet érted.
>> De ma megyünk összpontosítani A inicializálás itt,
képeket jelenít meg a videót rész, és kezelési bemeneti eseményeket.
Tehát ezek a fő szakaszain dokumentáció
hogy meg kell aggódni.
Just for fun, ha átmegyünk Itt és kattintson API megnevezés,
látunk egy listát minden Egyetlen dolog a SDL könyvtárat.
Tehát mindezeket a funkciókat, felsorolások, struktúrákat, egy őrült mennyiségű cucc,
ábécé sorrend.
És világosan, amíg tudod, mit csinálsz,
ez nem lesz túl hasznos, ezért teszünk API kategória.
>> Szóval kezdjük.
Remélhetőleg akkor már Letöltöttem a forgalmazás kódot.
És így mit tehetünk, jobb itt a CS50 készüléket,
egyszerűen nyiss egy terminált.
Essünk neki.
Szóval már letöltötte a forgalmazás kódot a .zip
módszer.
És én már kicsomagolt azt.
Tehát itt van a SDL szemináriumon mester.
Így fogok menni ebbe a könyvtárba.
És mit látunk itt hogy mi hét C-fájlok.
És ez lesz a kód fogunk vizsgálni ma.
Van egy makefile.
És van egy erőforrás könyvtár, amely egyszerűen egy kép
hogy máris látni elég hamar.
>> Szóval nyitni ezeket a fájlokat A g-Edit szerkesztő.
Szóval azt akarom megnyitni azokat a fájlokat Először is köszönjön, és véget .c.
Essünk neki.
Szóval ez egy apró ablak, így vagyunk megpróbálom, hogy ezt a nagyobb.
Nem, elment.
>> Minden rendben.
Tehát itt a legelső fájlt fogunk nézni.
Úgy hívják hello1_sdl.c.
És mindez nem az, formázza meg a SDL könyvtár, hogy mi is elindíthatjuk.
Honnan tudod, hogy jöjjön fel ezt a kódot magad?
Nos, ha megnézzük alatt A dokumentációt
és bemegy az inicializálás és állítsa le a rész,
ez fog mondani minden hogyan kell inicializálni SDL.
Tehát feltétlenül olvassa el ezt egy másik alkalommal.
Meg fog mondani mindent arról, hogy mi folyik itt.
De a fő dolog bökkenője az, hogy meg kell hívni ezt a funkciót SDL In It
és adja át milyen dolog szeretnénk a könyvtárat inicializálni.
Tehát a mi esetünkben, mi csak megy elindítani a videót most,
hogy mi lehet kezdeni képek megjelenítésére.
>> Több mint itt, akkor láthatja, ha rákattintunk egy SDL-t, mi
lehet, hogy még több információt, beleértve a visszatérési érték.
Tehát azt látjuk, hogy itt ez returnes nulla sikerrel.
Tehát a mi kódot, megyünk nézd meg, hogy nem tér vissza nullára,
és ha ez nem tér vissza nulla, ezért nem volt sikeres,
akkor megyünk egyszerűen print egy hiba segítségével ez az egyéb funkció,
SDL kapok, amely visszaadja a karakterlánc leírja, a hibát.
Fogunk nyomtatni, hogy hiba, majd mi csak
majd kilép a programból hibaüzenettel.
>> Aztán egy másik dolog, hogy meg kell tennie, mielőtt program kilép,
ha sikerült inicializálni SDL, csak meg kell nevezni az SDL kilép.
És hogy fog kezelni megtisztítása minden SDL belső erőforrások velünk.
Így a dokumentáció there-- újra, Itt vagyunk az indító
és állítsa le a rész A dokumentáció.
Akkor csak kattints a Ugyanis itt, SDL kilép,
és akkor olvassuk el azt is.
És sok ilyen funkció dokumentáció oldalak
Van példa kód, így ez a nagyon jó forrás.
Határozottan eltölteni egy kis időt olvasás részei ennek a wiki
ha meg akarsz csinálni ez a projekt.
>> Minden rendben.
Szóval ez az egész programot.
Mit tehetünk most is-- vagyok nyitod a Makefile Itt,
így fogok arra, hogy egy nézd meg, hogy hogyan működik.
És ez egy nagyon egyszerű makefile, hasonló ahhoz, amit eddig láttam.
Az egyik fő különbség az, hogy itt, ebben a
fog szúrni elért eredmény a A parancs, amelyekről már
telepített ha telepített SDL.
És ez egy parancs hogy fog generálni
néhány extra zászlókat a fordító számára.
>> Amellett, hogy, hogy mi így ez a szokásos parancsokat, valamint a
ez a két parancs.
Tehát a -lsdl2-kép fogantyúk összekapcsolása a SDL könyvtár.
És a -lm ténylegesen kezeli összekapcsolása A szabványos C matematikai könyvtárat.
Tehát nem lesz szüksége azok minden kedves C-fájlok,
de mi csak tedd, hogy tudjuk használja ugyanazt a Makefile mindent
módosítások nélkül.
>> Több mint itt a források, ez hol lenne
tenni a fájlokat, hogy meg fogjátok összeállításához a projekt.
De mivel minden az én egyik C fájlokat innen van egy fő funkciója,
ez meg fog összezavarodnak ha tegyük mindegyiket.
Így fogok csak annyit, most, hello1_sdl.c,
ami az, amit csak nézett.
Tehát, ha megyek vissza több Itt, amit tehetek, hogy.
És mit tett ez csak összeállított, hogy az első fájl.
És akkor mi is írja ./game, mert ez a végrehajtható produkált.
És ez az volt nyomtatási inicializálás sikeres.
Így tettünk valamit jól.
De ez már unalmas, mert nem láttunk egy ablakot,
semmi körül mozgott.
>> Szóval jó, van SDL inicializálni.
Most pedig nézzük lépni valami egy kicsit érdekes.
Tehát itt van hello2_window.c, és ez lesz valamivel
komplex C programot, amely inicializálja SDL mint korábban,
kivéve, hogy most mi is lesz inicializálni SDL időmérőt.
És ez meg fog hadd hozzáférni a belső időzítő
és használatára vonatkozó feladatát időt.
>> És akkor nézzük le ide.
Amit mi csinálunk itt van ez a mutató egy SDL ablakban struktúra, amely
lesz készítette ezt a hívást A funkció, SDL létre ablakot.
Most, hogy ez sok érvet, szóval menjünk nézd meg a dokumentációt.
Szóval megint megyek API kategória, én vagyok
lement a videót itt, és az első rész, megjelenítő ablakot menedzsment.
Tehát ez a rész egy csomó cucc benne,
de ha megnézed a ezeket a funkciókat, akkor
látom, hogy valószínűleg az, amit szeretnénk hívják SDL létre ablakban
amely történetesen igaza van a tetején.
>> És így ez a Ennek a funkciónak.
Az ablak megy, hogy egy címet, egy x és y pozícióját a képernyőn,
ez meg fog szélessége, magassága, és akkor fog telni néhány zászlókat.
Most, mi valójában nem érdekel ezek közül bármelyik zászlók most,
de ha akartam csinálni valamit mint hogy egy teljes képernyős ablakot,
ha lehetne egy pillantást arra.
Egyelőre mi csak megy hogy ezeket a különleges értékek,
SDL ablakban plusz központú X és Y érdekében
hogy csak teremt az ablakon közepén a képernyőn.
>> Szóval ezt, hogy csinál.
És ha történetesen ablakban null, ami azt jelenti, van egy hiba,
aztán megint mi csak fog nyomtassa ki a hibát használ SDL kapok.
És akkor azért, mert inicializáltuk SDL, most kell bezárni.
Így hívjuk SDL kilép, mielőtt vissza az egyik fő.
>> Tehát van nyitva ez az ablak reménykedve.
És mit fogunk tennie, hogy megyünk
hívni SDL 5000 milliszekundum, ami ugyanaz, mint öt másodperc.
És ha végeztünk azzal, ez meg fog pusztítani az ablakon,
tisztítsák meg az SDL könyvtárat, és kilép a programból.
Szóval menjünk előre, és ad, hogy egy lövés.
>> Tehát most módosítása helyett A makefile minden alkalommal,
Én egyszerűen nem teszik meg, és a majd a parancssorban,
mondjuk források megegyeznek az ÉS, majd A fájl vagyunk összeállításában.
Szóval ez hello2_window.c.
Fantasztikus.
Nem erros.
Most, ha futunk végrehajtható, látjuk ezt az ablakot.
Most van néhány Gondok vannak az ablakot.
Mi lehet mozgatni, de van Ennek fényében junk belsejébe.
Tehát mi nem húzott semmit, és így
Csak tele van szeméttel, amely nagyjából mi várunk.
>> Továbbá, mi nem zárja be az ablakot.
Én megnyomásával ezt az X sarok és semmi sem történik.
Szóval majd meglátjuk, hogyan kell rögzíteni hogy egy kicsit.
Úgyhogy erősít az a része, ahol a ablak tele van szeméttel először.
Tehát, ha átmegyünk hello3_image.c, mit láthatjuk, hogy mi felvettünk pár
több dolgot itt.
Már hozzá az új fejléc fájlt, hogy az időzítő funkció.
Azt hiszem, ezt tettük az elmúlt az egyik is, és én nem említette.
De most, mert mi vagyunk képekkel dolgozik,
megfelelően fel kell tüntetni az SDL A kép header fájlt is.
Szóval ez ugyanaz, mint a előtt, inicializálás SDL itt,
ugyanolyan foglalkozik létrehozása ablak.
Láttuk, hogy mielőtt őt.
>> Most arra van szükség, hogy hozzon létre egy úgynevezett A megjelenítő, amely egyfajta halad
ablak mellett.
De ez egy fajta absztrakt objektum, ami
felelős csinál mindezen rajzműveletek az ablakhoz.
És ez valóban megfelel a program betöltése
a grafikus hardver a számítógépen vagy a telefonon, vagy bármi.
Tehát a zászlók szeretnénk átadni it-- és akkor nézd meg a dokumentációt
hogy minél több részletet here-- mennek kell SDL tehetik felgyorsult, ami
azt jelenti, hogy lesz használja a grafikus hardver
és nem csak emulált szoftver.
>> És fogunk használni SDL renderer PRESENTVSYNC.
VSYNC egy dolog, hogy egyszerűen csak teszi A grafikus jobban néz ki, és megakadályozza
ezt a dolgot nevezett képernyőn terror, ahol a fele
Egy keret és a fele a következő keret kap húzott egyidejűleg
és úgy néz ki, rettenetes.
De újra, akkor menj olvasni arról, hogy a saját.
>> Így van némi zászlók itt.
És így mi csak akartam hívni Ezt a funkciót SDL létre renderelő.
Megyünk, hogy ez az ablak társítani, hogy renderelő.
Negatív azt jelenti, hogy nem érdekel, hogy mit grafikus driver fogunk használni.
Tehát, hogy amennyiben elég sok mindig negatív:
hacsak nem tudni grafikus vezérlő.
És akkor mi csak megy hogy adja át a zászlókat.
Tehát ha null értéket ad vissza, akkor nem vagyunk szeretnénk nyomtatni a hibát, mint rendesen,
de akkor mi is lesz hogy elpusztítsa az ablakon
hogy tisztítsák meg azokat a forrásokat, mielőtt hív SDL kilép, és visszatérnek.
>> Most, az érdekes rész itt ahol mi betölteni a képet
A funkció használata IMG_load.
Ez az egyetlen funkciója megyünk használja a SDL könyvtár.
Ez az egyetlen, amire szükségünk van.
Ez egy funkciója, amely során a húr hogy az az út, minden kép forrás.
És ez lehet egy PNG, GIF, bitmap, semmilyen ezeket a dolgokat.
És ez az, amiért ez a funkció, így szép.
Meg tudja kezelni elég sok olyan formátumban.
Betölti a memóriába, és eltárolja mint egy dologban egy SDL felületre.
>> Most egy SDL felülete csupán egy struct amely képviseli a kép adatokat a memóriába.
Szóval lehet többet megtudni hogy a dokumentációban kettő.
És ha ez a hiba, akkor nem vagyunk fog csinálni az egészet, ahol
kiírjuk a hibát, zárja be a erőforrásokat, majd lépjen ki a programból.
Most az érdekes dolog, mielőtt tudjuk felhívni ezt a képet az ablak,
azt kell, hogy ténylegesen, hogy ez egy textúra.
Most egy textúra megfelel a képadatok betöltött
a grafikus hardver memóriáját.
>> Tehát egy felület a fő memória, rendszeres memória
hogy a korábban használt összes félévben, és textúra e különálló VRAM
memória, hogy a grafikus kártya ellenőrzése.
Így hívjuk ezt a funkciót SDL_CreateTextureFromSurface.
Mi minden tőlünk renderelő és a felületre.
És akkor mi vagyunk a ténylegesen történik a felszínen,
úgyhogy most megyek kiszabadítani.
Nem kell többé.
És akkor így ha ezt a hívást errored és visszatért null,
akkor fogunk csinálni az egész hibajelentés dolog újra.
>> Minden rendben.
Itt most megkapjuk a néhány aktuális képi funkciók.
Szóval hívja SDL_RenderClear és átadása
A renderelő kapcsolódó ablakunk egyszerűen csak teszi az ablak elsötétül.
Tehát eltávolítja, hogy a szemetet, hogy láttuk ablakunk előtt, és teszi a fekete.
Aztán megyünk hívni SDL_RenderCopy,
hogy ez a megjelenítő, mi textúra.
És fogunk beszélni, hogy mit ezeken a területeken vannak egy kicsit.
De hogy fog hogy a textúra adatok
és másold rá is ablak felhívni a képet.
Tehát miután tettünk ezt a példányt Az adat-ra ablakunk,
meg kell tennünk ezt a plusz funkciója nevű SDL_RenderPresent.
>> És ez érdekes mert ez lesz
egy téma az úgynevezett kettős pufferelés.
Tehát kettős pufferelés olyan technika, amely teszi a grafikus sokkal jobban néz ki.
Ismét megakadályozza, hogy a képernyőn könnyezés Beszéltem korábban, ahol
van két pufferek.
Van egy hátsó puffer memória és egy elülső puffer.
Az első puffer szó mi van a képernyőn abban a pillanatban.
Tehát mi ezeket a változatokat dolgozzon, mint az SDL tehetik másolatot vagy SDL_RenderClear
a hátsó puffer.
Így módosítja a dolgokat a hátsó puffer.
Itt lehet rajz ezt zöld négyzet a hátsó puffer.
>> Így aztán ha megvagyunk csinál mi teszi műveletek, amelyek
Lehet, hogy egy nagyon hosszú ideje, mit fogunk csinálni
van váltani a pufferek.
Tehát szó szerint csak úgy elülső puffer és a hátsó puffer
és kapcsolók őket, így hogy azonnal,
egy műveletben, ahelyett, Talán száz vagy több ezer,
Minden újonnan nyújtott tárgyak a képernyőn.
És ez megakadályozza a dolgokat mint a képernyőn frissítő
amikor már csak a fele húzott A tárgyaink a keret.
Tehát ezért kell hívnunk SDL_RenderPresent, valamint
mint SDL_RenderCopy.
>> Ismét mi csak megy hogy várjon öt másodpercet.
Aztán megyünk tisztítsák meg a források.
Van jó néhány még ebben az időben.
És akkor mi csak megy A kilépéshez.
Tehát lássuk, hogy.
Megyek írja make, majd forrásokból egyenlő hello-- ez most 3image.c.
Rendben, hogy össze nem hiba.
És itt láthatjuk, én már most húzott ki a képemet, Hello, CS50!
hogy mi ablakot, amely eltűnik öt másodperc után.
>> Nos, ez még vannak problémái, ugye?
Ez nem egy jó alkalmazás, mert amikor megpróbálja bezárni az ablakot,
semmi nem történik.
Hogy x még mindig nem reagál.
Szóval vessünk egy pillantást a következő kép, hello4animation.
Tehát ez a fájl hogy fog bevezetni
mozgó és a mozgás a képünket.
Mi is így fogjuk csinálni a ugyanaz, mint korábban,
kezdeményezni SDL, hozzon létre a ablakban hozza létre a megjelenítő,
betölteni a képet memória, hozza létre a textúrát.
Láttuk az összes ilyet.
Nos, ez új.
Fogunk még egy úgynevezett Egy SDL len, amely csak egy téglalapot.
Ha átmegyünk itt, tudjuk nem a keresés a SDL rect,
és láthatjuk, hogy ez egy nagyon egyszerű szerkezet.
Meg van egy X, A y a pozíció, és azt
van szélessége és magassága a a méret a téglalap.
>> Szóval, mit fogunk csinálni a mi fogja meghatározni ezt az SDL len cél,
az úti cél.
És ez az a hely a képernyőn, ahol
mi lesz rajz mi kép jobb így
ha már lesz mozog a kép körül,
akkor a hely, ahol fogjuk hívni a kép
kell mozogni.
Mi is így fogjuk hívni ezt funkciót SDL_QueryTexture.
És észre én halad a címet A dest.w, amely a szélesség,
és dest.h, amely az a magasság.
És így SDL_QueryTexture megy tárolni ezeken a területeken a szélessége
és a magassága a textúra.
>> És akkor mit fogok tennie, hogy megyek
beállítani dest.x lenni ablakban szélesség mínusz dest.w, amely
a szélessége a Sprite, osztva 2.
És ez meg fog beállítani úgy, hogy a kép tökéletesen középen
a mi ablakot, rendben?
Tehát most van egy y pozícióját.
És ez lesz egy változó, ami
változó, mert mi lesz mozgó a képen az y irányban.
És most van valami nevű animációs hurok.
>> Tehát hogyan működik az animáció dolgozni?
Nos, az emberi szem által érzékelhető 12 külön Képek másodpercenként, rendben?
Tehát, ha villog 12 kép kártyák rám a második, láttam minden egyes ilyen képek
a saját elkülönült adott képet.
Most, ha villogni Képek rám egy második,
majd a szemem kezdeném elhomályosítja őket
és azt érzékeli, hogy a mozgás, egy helyett különálló képet.
Így például, filmek és televíziós, villan képeket, akkor 24-szer
egy másodperc.
Szóval ez másodpercenként 24 képkocka.
Számítógépes képernyők, másrészt, gyakran 60 képkocka másodpercenként.
Ez a frissítési sebessége.
Ez milyen gyakran frissül A kép a képernyőn.
Tehát célunk lesz 60 képkocka másodpercenként játékunk.
>> Tehát lássuk, hogy a kódot.
Tehát minden egyes képkocka, mi vagyunk az első majd törölje az ablakot.
Ez az általános minta.
Mindig törölje a ablak minden egyes képkocka, majd
tegyenek meg mindent a rajz műveletek, majd a végén,
ne RenderPresent megmutatni a témától.
És akkor fogsz Van egy várakozás végén
várni, amíg a következő keretben kell kezdeni.
>> Tehát, ha csinálok egy csomó komplex számítási itt
tartott több mint 16 milliszekundum, lehetetlen lenne számomra
kap, hogy a frame rate 60 hogy Azt akartam, mert minden egyes képkocka
Túl sokáig számítani.
Továbbá, mi igazán tesz fajta elhanyagolható mennyiségű munkát
itt, mert ott csak Egy dolog vagyunk rajz.
Szóval én csak várni 1/60 második, amely a hossza
egy keret a képkockák között.
Tehát én vagyok a fajta úgy tesz, mintha csinál minden munkám amely szinte nulla idő.
De egy igazi játék, azt kell kivonni
mennyi időt vett csinálni ezt a munkát az Ön pihenőidőt.
>> Mindegy, mi vagyok én valójában csinál ebben a hurok?
Én törölje az ablakot.
Én meg a dest.y, ami egy int, hogy Az aktuális y pozíció leadott egy int.
Most azt akarom, úszó felbontás az én y pozícióját a játékom,
de aztán, hogy ténylegesen felhívni rá a képernyőre,
szükséges ints, mert egységekben pixel, hogy az, amit a szereposztás az.
Megyek felhívni a képet.
Tehát ez a forrás téglalap.
És ez az a hely téglalap.
Szóval telt null A forrás téglalap
mondani szeretném felhívni én egész textúra.
De ha volt egy csomó textúrák a játék
és ők mind egy nagy textúra térkép hogy töltöttük SDL, mint csak egy
textúra, amit lehetett használja forrásként téglalap
felvenni az egyik a kisebb textúrák, az egyik a kisebb sprite,
ki, hogy a nagy textúra térkép.
>> Szóval megint én vagyok elhaladó én render, én textúra, és most a cél.
Ez lesz, ahol a ablakban meg fog levonni.
És akkor, mert én animátori valamit, kell a mozgás,
Megyek frissítjük a sprite elhelyezkedés minden egyes képkocka.
Szóval van ez az állandó nevezett scroll gyorsítsa egységekben pixel másodpercenként.
Most, minden alkalommal teszünk egy mozgalom, A keret csak 1/60 másodperces.
Így fogok osztani, hogy a 60.
És akkor lássuk, én vagyok levonásával származó y pozícióját.
Miért kivonva?
Mi lesz, hogy egy másodperc.
Így aztán törölni az erőforrások és a program vége.
>> Tehát tegyük ezt.
Szóval menjünk be make SRC = hello4 animation.c, rendben?
Játék.
Nesze.
Szóval van ez görgetés fel a ablak, ami elég ügyes.
De várj, én kivonva A y pozícióját minden alkalommal.
Mi folyik ott?
Nos, kiderült, hogy a SDL, és sőt, a legtöbb számítógépes grafika,
eredetét a koordináta-rendszer a bal felső sarokban az ablak.
>> Tehát a pozitív x irányba megy szerte az ablakot, hogy a jobb oldalon.
És a pozitív y irányban valóban lemegy.
Tehát még egyszer: a származási azon a A bal felső sarokban az ablak,
pozitív y irány lefelé, és a pozitív x jobbra.
Tehát amikor a kivonáshoz Az Y-pozíció, ez
megy, hogy ez megy a negatív y irányba, ami az ablakot.
Szóval ez, mi folyik ott.
Hűvös.
>> Nézzük meg a következő fájlt.
Itt az a része, a mutatni, ahol végre
kap, hogy X a sarokban az ablak ami állítólag az ablak bezárásához
dolgozni.
Szóval mi folyik itt?
Inicializáljuk SDL, hozzon létre az ablakon, hozzon létre a megjelenítő, betölteni a képet,
megteremtse a textúra mint láttuk korábban.
Mi ugyanazt a rendeltetési téglalap mint korábban, ugyanazon a hívást lekérdezheti textúra.
De ezúttal, mi majd fog osztani a szélessége
és a magassága célunkat 4.
Ez csak az a hatása, méretezés a kép lefelé, amikor
jelenítjük meg azokat az ablakban négy.
Szóval ez elég ügyes.
Mi is csak méretarányos csak úgy.
Fogunk kezdeni a kobold a képernyő közepén.
És most van x és y sebesség és Mindketten fog nulláról indulnak.
>> Ez a hibás fájlt.
Elnézést.
Szóval ez mind igaz.
Ez még mind ebben az állományban.
Megvan a szakadék a 4. és mindent.
Tehát itt van a mi x és y pozícióját Az ablak közepén.
És hogy ez a kezdeti sebesség E állandó sebesség, amely
Hiszem 300 képpont másodpercenként.
Most már ezt int is ugyanúgy egy logikai úgynevezett közel kért.
És ahelyett, hogy egy végtelen ciklus egy időzítő itt,
mi lesz animált, mint amíg közel nem kért.
>> Szóval hogyan dolgozzák fel az eseményeket?
Nos, SDL sorba fel eseményeket szó sorban a színfalak mögött.
És akkor minden egyes képkocka, tudjuk dequeue események
ebből a sorból segítségével ezt a felhívást SDL_PullEvent.
És ismét, feltétlenül menjen olvasni erről a dokumentációban.
Van egy sokkal részletesebb és sok Több használható funkciók ezzel.
Mi adja át a címet ez a dolog, SDL_Event
hogy itt van a verem.
>> Nos, mi egy SDL_event?
Mivel az SDL, ha megnézzük a A documentation-- nézzük
lásd API kategória, bemeneti események, eseménykezelés,
akkor nézd meg a számot A különböző események itt
és láthatjuk van egy egész csomó közülük.
Szóval mi ez a SDL_Event dolog?
SDL_Event uniója.
Hú, mi az a szakszervezet?
Akkor valószínűleg még sohasem hallottam ilyet.
És ez rendben.
>> A szakszervezet olyan, mint Egy struct, kivéve a struct
van hely az összes az EKB és a memória,
mivel az unió csak elég hely, hogy illeszkedjen a legnagyobb
annak egyik mezők, ami azt jelenti, csak tárolni egyik mezők
egy időben, milyen van értelme események, ugye?
Mi lehet a billentyűzet esemény vagy egy ablak esemény,
de egyetlen esetben sem lehet egyszerre billentyűzet esemény és egy ablak esemény,
így lenne butaság, hogy helyet mind a két belső rendezvényünk unió.
Tehát, ha akart létrehozhatunk saját unió
úgy néz ki, pontosan ugyanaz például létre a struct,
kivéve, hogy használjuk az unió kulcsszó ahelyett, hogy a struct kulcsszó.
És ne feledd, minden a dolgokat belül a szakszervezet,
a tényleges változó, hogy az unió Egyszerre csak egy ilyen értékek
egy időben.
>> Tehát hogyan tudjuk megmondani, hogy milyen esemény mi csak pattant ki ennek a sorból?
Nos, tudjuk tesztelni a event.type.
És ha ez egyenlő hogy SDL_Quit, tudjuk,
ez az esemény, hogy a keletkezett, amikor
hit, hogy X a sarokban az ablak.
És tudjuk meg közel kért értéke 1.
A többi csak néhány animáció hogy már látott.
Szóval menjünk előre, és a ez, és milyen jól működik.
Így fogok beírni gyártmánya és majd SRC = hello5_events.c.
Ott vagyunk.
Játékok.
>> Most azt látjuk, hogy Valóban kicsinyítve néggyel.
És most pattogó körül.
Van néhány ütközés detektálás folyik az oldalán az ablak
hogy mi is megnézzük.
És mi történik, ha megyek zárni?
Ez bezárja.
Fantasztikus.
Kaptunk az esetben.
És mi kezelte.
>> Szóval nézzük vissza a kódot.
Szóval hogyan jutok el pattogó körül, mint ez?
Ne feledje, én meg x és y kezdetben a sebességet.
És a sebesség a pozitív állandó, szóval
fogjuk kapni kezdik el lefelé és jobbra.
>> Most, minden egyes keret, továbbá a kezelési minden esemény előfordult,
Megyek felismerni, hogy én sprite próbál menni az ablakon.
Így nem tehetünk, hogy a csak ellenőrzés x_pos 0, y_pos 0, majd
is x_pos és y_pos a ablak szélessége és magassága ablakot.
Figyeljük meg, amit le kell vonni a szélessége a Sprite.
És ez azért van, mert ha nem tenném kivonni a szélessége a sprite,
ez csak ellenőrzi, hogy eredetét a sprite
nem megy az ablakon.
De mi szeretnénk az egész szélessége a sprite
hogy mindig az ablakon belül, és a teljes magassága a Sprite
hogy mindig az ablakon belül.
Szóval ez az, amit a kivonás számára.
Sok geometria itt lehet hasznos lehet felhívni, hogy ki
papíron a koordináta- rendszer, hogy mi folyik itt.
>> Tehát ha én ütköznek, csak egyszerűen indítsa újra a helyzetben
úgy, hogy nem megy ki a képernyőn.
És megyek, ha pattog az egyik az oldalfalak,
Megyek, hogy tagadja a x sebesség úgy, hogy
kezdődik pattogó a másik irányba.
És hasonlóképpen, ha eléri A felső vagy az alsó,
Megyek meg a y sebesség egyenlő a negatív Y sebesség,
úgy is, hogy vissza ugrál.
Szóval ez csak, hogyan jutottunk, hogy itt.
>> És a frissítést pozíciók mint láttuk korábban,
ossza el 60, mert mi vagyunk Csak kezelési 1/60 másodperces.
És akkor teszi, pontosan ugyanaz, mint korábban.
És így ez minden hogy folyik ez a fájl.
Szóval így teszünk események.
A legfontosabb dolog, hogy elvegye itt ez SDL_PullEvent funkciót.
És akkor feltétlenül olvassa el a dokumentációt többet SDL_Event
a szakszervezet, mivel ezek az adatok típusa Nagyon, nagyon fontos, mert mi használjuk
mindenféle események.
>> Például, azt használjuk billentyűzet eseményeket, ami mi ez a fájl a.
Akkor mi van?
Megvan ugyanaz, mint korábban, alaphelyzetbe SDL, hozzon létre egy ablak,
hozzon létre egy megjelenítő, betölteni a képet a memóriába, hozza létre a textúrát.
Ismét megyünk ezt dest téglalap,
megyünk a képméret négy, hogy ez egy kicsit kisebb.
Most fogjuk kezdeni a sprite a képernyő közepén.
De ezúttal, megyünk állítani a kezdeti X és Y sebességek nulla,
mert a billentyűzet lesz, hogy ellenőrizzék azokat.
Továbbá, megyünk nyomon követni ezeket a változókat
fel, le, balra és jobbra.
És hogy fog tartani követni, hogy mi már
Megnyomta a billentyűzet gombjai megfelelnek az fel, le, balra,
és jobb.
>> Nos, ez a fajta képzelet mert tudjuk használni a W, A, S,
D itt, vagy a tényleges nyilakkal.
Meglátjuk, hogy csak a második.
Mi is így fogjuk feldolgozni A rendezvény, mint korábban.
Mi húzza az eseményt.
De most megyünk kapcsolja be az esemény típusát.
Ha ez SDL_Quit vagyunk fog készlet közel
kérte, hogy az egyik, mint azelőtt.
Amely kezeli az x-et A sarokban az ablak,
úgy, hogy az ablakunk valóban bezárja.
>> Ellenkező esetben, ha kap egy SDL gomb lefelé eseményt, ami azt jelenti, megnyomott egy gombot,
akkor mit fogunk csinálni a mi majd kapcsolja be ezt a dolgot itt,
amely means-- így event.key azt jelenti, kezeljük a rendezvény szakszervezet,
Menj, és a kulcsot esemény szerkezet benne.
Így kiderül, hogy ez a unió egyik legfontosabb esemény struktúrát.
És akkor megy a kulcs Amennyiben szerkezetét a területen
nevű _keysym majd scancode.
És ismét határozottan olvasni A dokumentáció erről.
Kulcsszó bemenetek elég érdekes.
Lehet kapni leolvasó kódok vagy kulcskódok.
És ez egy kicsit finomabb, de A dokumentáció elég jó.
>> Tehát, ha azt látjuk, a szkennelés kódot mi gombnyomás, hogy W vagy felfelé,
fogunk létrehozni egyenlő 1.
És akkor mi kitörni, hogy kapcsolót.
Ha ez egy vagy balra, mi meg hagytuk 1 et cetera, et cetera, a jobbra lefelé.
Most, ebben a külső kapcsoló, ha látunk egy gombot felfelé esemény,
ez azt jelenti, amit kiadott egy billentyűt és mi már nem nyomja rá.
Így fogok mondani akár értéke 0, bal értéke 0, lefelé értéke 0, a jobb
értéke 0, satöbbi.
>> És észre mi minden ilyen két esetben rendbe egymás mellé
nincs külön kód Az első esetben, amely
azt jelenti, hogy függetlenül attól, hogy S vagy lefelé itt,
ez meg fog végrehajtani ezt a kódot.
Szóval ez elég praktikus.
Ez megakadályozza, hogy kelljen többet feltételeket és az IFS és a dolgok
mint az.
>> Szóval megyünk sebességének meghatározása.
Mi meg a sebességet 0.
Akkor, ha fel van nyomva és nem le, akkor
Állítsa be az Y sebesség negatív sebességgel.
Emlékezz negatív, mert a negatív y iránya fel.
És a pozitív y irányban működik.
Ha le van nyomva és nem felelnek meg, akkor nem vagyunk
megy úgy beállítani, hogy a pozitív sebesség, ami azt jelenti, megy le a képernyőn.
Ugyanaz a bal és a jobb.
>> És akkor mi lesz frissíteni A pozíciók, mint korábban.
Fogunk csinálni ütközés érzékelés határait,
de nem fogunk állítani a sebesség, mert a sebesség csak
vezérli a billentyűzetet.
De mi lesz, hogy visszaállítsa a pozíciókat tartani az ablakban.
És mi lesz állítva a pozíciókat a struct
majd tegye az összes rendering cuccot előtt.
Nézzük, mit csinál.
Úgyhogy győződjön SRCS-- lássuk, ez hello6_keyboard.c.
>> Ó, nem.
Szóval van egy kis figyelmeztetés itt.
És ez egyszerűen azt mi nem ellenőrizze minden egyes lehetséges fajtája
A rendezvény.
Ez rendben van, mert van 236, vagy úgy.
Így fogok figyelmen kívül hagyni azokat a figyelmeztetéseket.
Még mindig össze finom.
Így fogok játszani a játékot.
Hogy nem mozog.
De most, amikor a cefre a billentyűzetem, Meg tudom csinálni néhány WASD mozgás van,
Tudom használni a nyilakkal is.
És észre, bár én vagyok megnyomása jobb most,
ez nem fog ki az ablakon, mert visszaállíthatja minden kockánál.
Szóval ez elég ügyes.
El lehet képzelni körül mozog Mario Néhány nyilakkal, vagy valami ilyesmi.
És igen, az X nem működik.
>> Tehát végső fájl megyünk nézni, hellow7_mouse.
Ez arról szól, hogy az egér bemenet.
Tehát ez, azt importálja a matek fejléc,
mert mi lesz, hogy Egy kis matek van.
Ugyanaz a régi, régi dolgokat, cél, régi, láttam ilyet.
Nos, ez érdekes.
Úgyhogy vissza, hogy csak megnézni Az SDL kilép eseményt.
Miert van az?
Így kap egér beviteli eseményekről.
Mint amikor az egér mozgott, kapsz egy esemény, hogy.
Amikor egy egér gomb megnyomásakor akkor kap egy esemény, hogy.
>> De van egy másik, valamivel egyszerűbb talán API egyre egér bemenet.
És ez csak az SDL get egér állapotban.
Szóval van egy int az x és y a kurzor pozícióját.
Azt adja át a SDL_GetMouseState, amely meghatározza ezeket.
És ez pozícióját a koordináta-rendszer az ablakon.
Tehát ha a tömeg a bal felső Az ablak, amely 0, 0.
>> Most, hogy mit fogok csinálni, hogy én megyek hogy csinál egy kis vektoros matek.
Fogadok azt hitted, hogy nem Látható, hogy CS50, de itt van.
Megyek, hogy némi vektor matek, hogy a vektor
a képen a kurzort.
És így miért nekem kell ez a kivonás itt?
Nos, ha én csak használni dest .-- így Meg kell fordítani az egér x
és y által a szélesség fele és a magassága a kép,
mert azt akarom, a központ a A kép, hogy megy felé az egér,
Nem származik a kép.
>> Szóval ez csak a biztonság kedvéért beszélek a központ a kép itt.
Aztán kapunk Delta X és Y, amely a különbség a megcélzott
a tényleges helyzetnek a kép.
És akkor juthatunk a távolság van, ami
lesz Pitagorasz tétel x négyzetgyöke
szor x plus y-szor y.
>> Most, hogy megakadályozzák remegést, és meg tudom mutatni Ön mit is csinál ez, ha nem teszem ezt,
ha a távolságot a kurzor és a kép közepén kisebb, mint öt,
Én csak nem fog mozogni a képet.
Ellenkező esetben, mi meg a sebességet.
És mi meg úgy, hogy a sebessége mindig állandó marad.
És a nettó eredmény az összes ez Math az, hogy a kép
megy felé a kurzort.
>> Most kiderül, hogy SDL_GetMouseState,
továbbá a beállítást a x és y érvek itt,
ez is visszatér egy int, amely megfelel hogy az állam az egér gombjait.
Tehát nem tud olvasni, hogy közvetlenül, de lehet
használja ezeket a makrókat, egyetlen bitenkénti üzemben, nem olyan ijesztő,
Csak egy bitenkénti és.
Tehát azt mondjuk gombok, ami annak az eredménye A mi SDL_GetMouseState, ha ez a
és bitenkénti és ez makró Itt, SDL_BUTTON_LEFT.
>> Szóval ez lesz egyszerű megoldani A bitmap, amely megfelel
hogy az egér bal gombját nyomva tartják.
És így, ha a bitenkénti és lép fel, és ez
nem nulla, ami azt jelenti, bal gombot nyomta meg,
akkor mi történt valójában, hogy tagadja mind az x és az y sebességek,
ami csak hogy a kép szökött.
Frissítés pozíciókat.
Ütközések észlelések, láttam minden előtt, vakolás, minden rendben.
Tegyünk.
Szóval van, hogy SRC = hello7_mouse.c.
Nagy.
Nincs hiba.
És a játék.
>> Tehát itt van az egér.
És a kép valóban üldözi a képre.
Most, a játék csinál, talán ez olyan, mint egy ellenséges üldöző
A kis karakter, vagy bármi.
De itt van a A kép kergeti az egeret.
És ha rákattintok, az egér indul kergeti a kép
és a kép menekül a képre.
Szóval ez elég jó.
És észre ismét, van még ütközés észlelése itt.
>> Tehát ez a végső kis demo állítottam fel itt.
És vessünk egy pillantást még egy dolog.
Szóval vissza ide, említettem ezt a remegést.
Minden rendben.
Tehát, ha a távolság kisebb, mint öt képpont, Én beállítása x és y sebesség nulla.
Mi történik, ha megszabadulunk, hogy?
Szóval megyek, csak ezt.
Kérlek, bocsáss ezt a borzalmas stílusban, de megjegyezte ki a helyes kódot.
Így fogok menteni, hogy, és nem a ugyanazt a parancsot előtti tenni.
>> Minden rendben.
És most mi lesz?
Jó.
Még mindig követi a egér, mint korábban,
de ha eljutunk az egér, megvan ez a bruttó remegést.
Mi folyik ott?
Nos, a mi vektor matek, emlékszem voltunk
figyelembe a távolság a A kurzor és a központ a kép?
Nos, ahogy megközelíti 0, akkor elkezd egyre
mint ez a fajta őrült viselkedés ahol a kép a fajta
mint oszcilláló körül a kurzor.
És ez létre ezt a remegést.
És ez nagyon csúnya.
És akkor valószínűleg nem szeretné, hogy a játékok csinálja,
hacsak nem valami különleges hatást.
>> Szóval ezért van Csak ez az önkényes
levágta az öt pixel, ahol azt mondjuk, ha ez öt pixel, jók vagyunk.
Nem kell mozgatni a kép többé.
Szóval ez, mi folyik ott.
>> Szóval ez elég sokat.
Most már tudja, hogyan kell létrehozni ablak, töltse be egy képet,
felhívni egy képet az ablak, hogy billentyűzet, egér beviteli kap,
van egy csomó más input, amit nem
tudom, hogyan lehet, ha csak eltölteni egy Néhány perc nézi dokumentációt.
Így valóban meglehetősen Néhány eszköz a rendelkezésére áll most
hogy írjon egy teljes értékű játék.
>> Most minden játékban kell egy kis hang, de a hang dokumentáció
Az is nagyon jó.
És nem vagyok hajlandó fogadni, hogy ha Ön megértse a dolgokat
beszélgettünk ma A képek és felületek,
Az ablakok, és mindent, majd kitalálni a hang API nem
lesz olyan rossz.
Szóval várom, hogy lássam mit hoz létre SDL.