THOMAS JAUTRA: Nu labi.
Sveiki visiem.
Es esmu Thomas Lively.
Šis seminārs būs rakstiski 2D spēles C, izmantojot SDL.
Tāpēc es zinu, ka tu esi visu jautā, jā, es tiešām
vēlaties spēlēt spēles un padarīt spēles, bet to, kas ir šis SDL bizness?
Tātad SDL ir C bibliotēka.
Tas apzīmē Simple Directmedia Layer.
Un tas ir pāri platformas, spēļu izstrāde bibliotēka.
Tas darbojas uz Windows, Mac, Linux, pat iOS un Android.
Tā rīkojas lietas, piemēram, piekļuve audio sistēmas
par datoru, klaviatūru, un pele, kursorsviras, ja viņi pievienots.
Par mobilo, tas var pat darīt pieskarties ievadi un viss kas.
Un, protams, to rokturi grafikas, zīmēšanas lietas uz ekrāna.
>> Tātad, tas ir ļoti plaši izmantots, kaut gan Jūs, iespējams, nav dzirdējuši par to pirms tam.
Tas ir iebūvēts, piemēram, Valve avots dzinējs,
kura pilnvaras spēles, piemēram, Portāls un Team Fortress 2.
Tas ir arī ļoti liels skaits no indie spēles, kas nāk ārā,
tāpēc es esmu satraukti, lai redzētu, kas jums viss būs veikt ar to.
>> Semināra mērķi ir, lai saņemtu jums noteikti, lai būtu attīstīt ar SDL.
Mēs ejam, lai uzzinātu, kā lai izveidotu spēles logu.
Mēs ejam, lai radītu sprites, kas ir attēli savu spēli
kas var pārvietoties.
Mēs ejam, lai uzzinātu, kā lai un animēt sprites,
tāpēc pārvietot tās apkārt, padarīt viņiem mainās laika gaitā.
Un mēs ejam, lai uzzinātu, kā lai attēlotu tastatūru un peli
ievade no datora.
Ko mēs nebūs runāt Par šodien ir 3D grafika,
jo tas ir ļoti sarežģīti temats, ka mums nav laika.
Mēs ne iemācīties atskaņot audio uz mūsu spēlēm.
Un mēs nebūsim ēka par kaut ko, bet Linux.
>> Tagad brīdinājumi tur ir, ka, cerams, līdz gada beigām seminārs,
jūs būsiet apmierināti ar SDL dokumentācija,
lai jūs varētu doties izrēķināt kā spēlēt audio pats.
Arī ēkas Mac vai PC jāstrādā tieši tāds pats kā celtniecības Linux,
bet iestatīšanas gatavojas būt nedaudz atšķirīgs.
Tātad jums vajadzētu būt iespējai izrēķināt , kā to darīt šīs lietas
beigās šodienas seminārā.
>> Tātad, kas izveidota, mēs ejam izmantot virtuālo mašīnu.
Mēs varētu izmantot CS50 IDE, jo mēs esam tikai gatavojas rakstot C
Bet, tā kā IDE nav pārlūks, mēs nevar radīt jaunus logus vai displejs
grafikas tajā.
Tāpēc mums ir nepieciešams virtuālo mašīnu.
Tātad jūs varat sekot instrukcijām šeit manual.CS50.net/appliance/15~~pobj
instalēt oficiālo CS50 ierīci, kas ir tikai Linux virtuālā
mašīna.
>> Un tad, kad jums ir ka visi, kas to up--
var aizņemt nedaudz, bet, jo ļoti liels download-- jūs dodas
palaist ar VM sudo apt-get update.
Un tas tiešām notiek atjaunināt visu programmatūru
paketes uz jūsu virtuālo mašīnu.
>> Pēc tam, jūs gatavojas palaist sudo apt-get install, libsdl2-2.0-0,
libsdl2-dbg, libsdl2-dev, un papildus libsdl2-image-2,0-0,
libsdl2-image-dbg, un libsdl2-image-dev.
Tātad, ko tas dara?
Ka tikai instalē debug informāciju, dokumentus, galvenes,
un binaries divām bibliotēkām.
Regulāra vecs, SDL 2.0, un citu bibliotēku
sauc SDL Image, kas mēs ejam, lai, izmantojot
ielādēt attēlu failus mūsu spēli.
>> Tātad, kad jums ir, ka arī ka, tikai tad, kad tā lūdz,
jūs vienkārši ierakstiet jā, hit Enter uzstādīt šīs paketes,
un tad jums vajadzētu būt labi iet.
Tātad, lai iegūtu sadales kodu, can-- Ak, dievs, tas nav atjaunināts.
Ja vien jums ir GitHub account-- ja Jums ir GitHub kontu,
jūs varat darīt šo GIT klons komandu uz repo
un kas būs lejupielādēt GIT repo ar visu kodu tajā,
tā, ka jums ir kodu.
>> Ja jums nav GitHub konts, kas jums jādara, ir veids
wgithttps: //github.com/tlively/sdl seminar-- un šeit tas ir different--
/archive/master.zip.
Tātad vēlreiz, tas ir tieši tā pati URL, izņemot tas būs
tlively / SDL_seminar / master.zip un jūs izmantojat wgit lejupielādēt to.
Un tad jūs varat vienkārši unzip ka arhīvs
un tad jums ir visu pirmkodu.
Tik žēl par to.
Un tad kods tiks izvietots pie uz CS50 Semināra mājas lapa pāris
dienas.
>> Viss kārtībā.
Tātad, kā mēs sāktu rakstot savu spēli?
Nu, pirmā lieta mēs esam gatavojas vēlaties darīt
ir apskatīt SDL dokumentāciju.
Tātad, šeit ir VM.
Un šeit ir mājas lapa.
Esmu navigāciju dzīvot libsdl.org.
Ko es esmu gatavojas darīt, šeit ir iet pa uz sānjoslas, ar dokumentāciju,
un noklikšķiniet uz wiki.
Tas dos man wiki, ka ir lielākā daļa no dokumentācijas SDL.
Virs uz sānjoslas šeit, mēs esam gatavojas noklikšķiniet API pa kategorijām,
jo gatavojas sniegt mums jauku kategorisks viedoklis
no visa API SDL.
>> Tā, piemēram, mums ir pamata inicializācijas
un slēgt, visu veida administratīvais sīkumi, izmantojot SDL,
un tad mums ir sadaļu attēlot lietas uz ekrāna.
Tas ir video.
Ievades notikumus, tas kļūst ieeja no klaviatūras,
iegūt datus no peli, un kursorsviru, ja esat to vēl.
Tur ir spēks Atsauksmes par lietām piemēram, spēļu kontrolieri, kas
mēs nebrauksim runāt.
Un šeit ir audio.
Un tad tur ir ķekars citu sīkumi, kas SDL var darīt jums.
>> Bet šodien mēs esam gatavojas koncentrēties uz inicializācijas šeit,
parādot attēlus video iedaļā, un apstrādes ievades notikumus.
Tātad šie ir galvenie sekcijas dokumentāciju
kas jums būtu jāuztraucas par.
Just for fun, ja mēs ejam pa šeit un noklikšķiniet uz API pēc nosaukuma,
mēs varam redzēt sarakstu ik single lieta SDL bibliotēkā.
Tātad visas šīs funkcijas, uzskaitījumu, konstrukcijas, crazy summu sīkumi,
alfabētiska secība.
Un skaidri, līdz jūs zināt, jūs darāt,
tas nebūs pārāk noderīgi, kas ir iemesls, kāpēc mēs to darām API pēc kategorijām.
>> Tātad, pieņemsim sāktu.
Cerams, ka jūs esat jau lejupielādēts sadales kodu.
Un tā, ko jūs varat darīt, ir, vai ne šeit CS50 ierīces,
vienkārši atvērt termināli.
Te nu mēs esam.
Tāpēc es esmu jau lejupielādējis sadales kodu, izmantojot .zip
metode.
Un es esmu unzipped to.
Tātad šeit tas ir SDL semināra kapteinis.
Tāpēc es iešu uz šo direktoriju.
Un ko mēs redzam šeit ir ka mums ir septiņi C failus.
Un tas notiek uz kodu mēs gribam būt apskatot šodien.
Mums ir makefile.
Un mums ir resursu direktoriju, kas vienkārši ir attēlu
ka jūs redzēt pietiekami drīz.
>> Tātad pieņemsim atvērt šos failus izmantojot G-Edit redaktoru.
Tāpēc es gribu atvērt visus failus, kas sākas ar sveiki un beidzas ar .c.
Te nu mēs esam.
Tā ka ir niecīga logs, tāpēc mēs esam gatavojas, lai mēģinātu darīt, ka lielāks.
Nē, tā aizgāja.
>> Viss kārtībā.
Tātad, šeit ir ļoti pirmais failu mēs ejam apskatīt.
To sauc hello1_sdl.c.
Un tas viss dara, ir inicializēt SDL bibliotēka, lai mēs varētu sākt to lietot.
Kā jūs zināt nākt līdz ar šo kodu sevi?
Nu, ja mēs skatāmies vairāk pie dokumentiem
un mēs iedziļināties inicializācijas un slēgt sadaļu,
tas notiek, lai pastāstītu mums visiem par to, kā inicializēt SDL.
Tātad noteikti izlasīt šo kādu citu reizi.
Tas notiek, lai jums pastāstīt visu par to, kas notiek šeit.
Bet galvenais lietas būtība ir tāda, ka mums ir nepieciešams, lai izsauktu šo funkciju SDL In It
un nodot to, kāda veida lietas mēs vēlamies, lai bibliotēka inicializēt.
Tātad mūsu gadījumā, mēs esam tikai gatavojas inicializēt video tagad,
lai mēs varētu sākt attēlot attēlus.
>> Nekā šeit, jūs varat redzēt, ja mēs noklikšķiniet uz SDL tajā, mēs
var iegūt vēl vairāk informācijas, tostarp atgriešanās vērtību.
Tātad mēs redzam šeit, ka tā returnes nulles uz panākumiem.
Tātad mūsu kodu, mēs ejam, lai redzēt, ja tas neatgriežas nulle,
un ja tas neatgriežas nulle, tāpēc tas nebija veiksmīgs,
tad mēs ejam, lai vienkārši izdrukāt kļūda, izmantojot šo citas funkcijas,
SDL get kļūda, kas atgriež virkni aprakstot kļūdu, kas noticis.
Mēs ejam, lai drukātu, ka kļūda, un tad mēs esam tikai
gatavojas iziet no programmas ar kļūdas kodu.
>> Tad cita lieta, ka mums ir nepieciešams to darīt, ir, pirms programma izejām,
ja mēs veiksmīgi inicializēts SDL, mums ir nepieciešams, lai izsauktu to SDL atmest.
Un kas notiek, lai apstrādātu sakopšanu visas SDL iekšējos resursus, lai mums.
Tāpēc dokumentācija there-- atkal, šeit mēs esam inicializācijas
un slēgt sadaļu dokumentācijas.
Jūs varat vienkārši noklikšķiniet uz funkcija šeit, SDL atmest,
un jūs varat izlasīt visu par to, kā labi.
Un daudz šīs funkcijas dokumentācijas lapas
ir piemērs kods, tāpēc šis ir ļoti labs resurss.
Noteikti pavadīt kādu laiku lasīšanas daļas šajā wiki
ja jūs gatavojas darīt tas par projektu.
>> Viss kārtībā.
Tātad tas ir mūsu visu programmu.
Ko mēs varam darīt tagad is-- es esmu gatavojas atvērt makefile šeit,
tāpēc es esmu gatavojas veikt skatīties, kā tas darbojas.
Un tas ir ļoti vienkāršs makefile, līdzīgs tam, ko jūs esat redzējis.
Viens no galvenajām atšķirībām ir tā, ka šeit, šajā
gatavojas ievietot rezultātu vadīšanas šī komanda, kas jūs esat jau
uzstādīt, ja jūs uzinstalēju SDL.
Un tas ir komanda kas notiek, lai radītu
daži papildus karogi par kompilatoru.
>> Papildus tam, mēs dodam to visas parastās komandas, kā arī
šīs divas komandas.
Tātad -lsdl2-image rokturi saistot ar SDL attēlu bibliotēkas.
Un -lm faktiski rokturi sasaisti standarta C math bibliotēka.
Tātad mēs neesam gatavojas nepieciešama tiem visiem mūsu C failu,
bet mēs vienkārši viņus tā, ka mēs varam izmantot to pašu makefile par visu
bez izmaiņām.
>> Vairāk nekā šeit avotiem, tas ir, ja jūs vēlaties
likt failus, kas jums gatavojas sastādīt savam projektam.
Bet, tā kā katru vienu no maniem C failus šeit ir galvenā funkcija,
tas notiek, lai saņemtu sajaukt ja mēs viņus visus.
Tāpēc es esmu gatavojas tikai teikt, tagad, hello1_sdl.c,
kas ir viens mēs vienkārši paskatījās.
Tātad, ja es iet atpakaļ pār šeit, es varu darīt darīt.
Un ko tas darīja tas ir tikai apkopoti šo pirmo failu.
Un tad mēs varam ierakstīt ./game, jo tas ir izpildāms tā ražota.
Un viss tas tomēr bija print inicializācijas veiksmīga.
Tātad mēs kaut ko labo.
Bet tas bija sava veida garlaicīgi, jo mēs neredzēju logu,
nekas netika pārvietojas.
>> Tik liels, mēs saņēmām SDL inicializēts.
Tagad, pieņemsim pāriet uz kaut ko nedaudz vairāk interesants.
Tātad šeit mums ir hello2_window.c, un šis būs nedaudz vairāk
sarežģīts C programmu, kas inicializē SDL tāpat kā līdz šim,
izņemot tagad mēs esam arī gatavojas inicializēt SDL taimeri.
Un tas notiek, lai mūs piekļūt iekšējo taimeri
un izmantot funkcijas, kas attiecas uz laiku.
>> Un tad pieņemsim skatīties uz leju šeit.
Ko mēs darām, ir mums ir šī rādītājs ar SDL logu struct, kas
tiks izveidota ar šo uzaicinājumu funkcijai, SDL veidot logu.
Tagad, tas aizņem daudz argumentu, tāpēc iesim apskatīt dokumentāciju.
Tātad vēlreiz, es esmu gatavojas API pa kategorijām, es esmu
iet uz leju līdz video šeit, un pirmais sadaļa, parādot logu vadību.
Tātad šī sadaļa ir ton sīkumi tajā,
bet, ja paskatās caur šīs funkcijas, jūs
redzēt, ka, iespējams, kādu mēs gribu sauc SDL radīt logu,
kas notiek, ir pašā augšā.
>> Un tā tas ir dokumentācija par šo funkciju.
Logs nāksies nosaukumu, X un Y pozīcija uz ekrāna,
tas nāksies platums, augstums, un tad tas notiek, lai veikt dažas karogus.
Tagad, mums nav reāli rūp kāds no šiem karogiem tieši tagad,
bet, ja jūs vēlētos darīt kaut ko piemēram, veikt pilna ekrāna logu,
jūs varētu to apskatīt to.
Tagad mēs esam tikai gatavojas izmantot šos īpašos vērtības,
SDL logu plus centrēts par x un y, lai
lai tikai radītu logu centrā mūsu ekrāna.
>> Tātad tas, ko tas dara.
Un, ja loga notiek, null, kas nozīmē, ka ir kļūda,
tad atkal mēs esam tikai gatavojas izdrukāt kļūdu izmantojot SDL saņem kļūdas.
Un tad tāpēc, ka mēs inicializēts SDL, mums tagad ir nepieciešams, lai to aizvērtu.
Tāpēc mēs aicinām SDL atmest pirms atgriežoties vienu galveno.
>> Tāpēc mums ir šis logs atvērts, cerams.
Un ko mēs ejam to darīt, ir, mēs ejam
aicināt SDL 5000 milisekundes, kas ir tāds pats kā piecām sekundēm.
Un, kad mēs esam darīts ar to, tas notiek, lai iznīcinātu logu,
sakopt SDL bibliotēku, un izietu no programmas.
So iesim uz priekšu un dot, ka vārtsargu.
>> Tāpēc tagad nevis mainīt Makefile katru reizi,
Es varu vienkārši izdarīt, un tad uz komandrindas,
saka avoti ir vienāds, un pēc tam fails mēs apkopošanai.
Tātad, tas ir hello2_window.c.
Fantastic.
Nav erros.
Tagad, ja mēs vadīt mūsu izpildāmā, mēs redzam šo logu.
Tagad tur ir maz problēmas ar logu.
Mēs varam pārvietot to apkārt, bet tas ir šī fona junk iekšpusē no tā.
Tātad mēs neesam sastādīts kaut kas, un tāpēc tas ir
tikai pilns ar atkritumiem, kas ir diezgan daudz, ko mēs sagaidām.
>> Bez tam, mēs nevaram aizvērt logu.
Es esmu nospiežot šo ar X stūra un nekas notiek.
Tātad mēs redzēsim, kā to salabot ka mazliet.
Tātad, pieņemsim noteikt daļu, kur logs ir pilna ar atkritumiem vispirms.
Tātad, ja mēs ejam pa to hello3_image.c, ko mēs varam redzēt, ir tas, ka mēs esam pievienojuši dažus
vairāk lietas šeit.
Mēs esam pievienojuši šo jauno galveni failu, lai iegūtu taimera funkciju.
Es domāju, mēs to izdarījām, ka pēdējā viens, pārāk, un es neminēja to.
Bet tagad, jo mēs esam strādājot ar attēliem,
mums ir nepieciešams iekļaut SDL image header fails, kā arī.
Tātad, tas ir tas pats, kas pirms inicializēšana SDL šeit,
pats nodarbojas ar radot logiem.
Mēs esam redzējuši, ka pirms tagad.
>> Tagad mums ir nepieciešams, lai radītu kaut ko sauc attēlotājs, kāda veida iet kopā
ar logu.
Bet tas ir sava veida abstrakts objekts, kas ir
atbild par darot visu šo zīmēšanas operācijas pie loga.
Un tas tiešām atbilst programmai iekrauta
uz grafikas aparatūras jūsu dators vai tālrunis vai neatkarīgi.
Tātad karogi mēs gribam iet it-- un jūs varat ielūkoties dokumentācijā
lai iegūtu detalizētāku informāciju here-- gatavojas kas SDL apmetuma paātrināta, kas
nozīmē, ka tas būs izmantojot grafikas aparatūru
un ne tikai atdarināt programmatūru.
>> Un mēs ejam, lai izmantotu SDL attēlotājs PRESENTVSYNC.
VSync ir lieta, kas vienkārši padara jūsu grafikas izskatās labāk un novērš
šī lieta, ko sauc ekrāns terors, kur puse
Viena rāmja un pusi no nākamā rāmis get sagatavots, tajā pašā laikā
un tas izskatās šausmīgi.
Bet atkal, jūs varat iet lasīt par to, ka par savu.
>> Tātad mums ir daži karogus šeit.
Un tāpēc mēs esam tikai gatavojas, lai izsauktu Šī funkcija SDL radīt attēlotājs.
Mēs ejam, lai dotu tai logu asociēt ar šo attēlotājs.
Negatīvs viens nozīmē, ka mums nav vienalga, ko grafikas draiveris mēs spēsim izmantot.
Tā, ka būtu diezgan daudz vienmēr būs negatīva,
ja vien jūs zināt par grafikas vadītājiem.
Un tad mēs esam tikai gatavojas nodot to mūsu karogus.
Tātad, ja tas atgriež null, tad mēs esam gatavojas drukāt kļūdas kā parasti,
bet tad mēs esam arī gatavojas iznīcināt logu
sakopt šos resursus pirms zvanot SDL atmest un atgriezties.
>> Tagad interesanti daļa šeit ir, ja mēs slodze mūsu tēlu
Izmantojot šo funkciju IMG_load.
Šī ir vienīgā funkcija mēs ejam izmantot no SDL attēlu bibliotēkas.
Tas ir tikai viens mums ir nepieciešams.
Tā ir funkcija, kas notiek virkne tas ir ceļš jebkuru attēlu resursa.
Un tas var būt .png, GIF, bitmap, kāda no šīm lietām.
Un tas ir iemesls, kāpēc šī funkcija ir tik jauki.
Tā var rīkoties diezgan daudz jebkurā formātā.
Kravas to atmiņā un saglabā to kā lieta, ko sauc par SDL virsmu.
>> Tagad SDL virsma ir tikai struct kas pārstāv attēla datus atmiņā.
Tātad jūs varat izlasīt vairāk par ka dokumentācijā divi.
Un, ja tas kļūdas, tad mēs esam darīsim visu lieta, kur
mēs drukāt kļūdu, aizvērt resursi, un tad atmest programmu.
Tagad interesanta lieta ir, pirms mēs varam izdarīt šo attēlu uz loga,
mums ir nepieciešams, lai tiešām padarītu to tekstūra.
Tagad tekstūras Atbilst ar attēla datiem piekrauts
pārvērta Grafiskais aparatūras atmiņā.
>> Tātad virsma ir galvenais atmiņa, regulāra atmiņa
ka mēs esam, izmantojot visu semestri, un tekstūra ir šo atsevišķo VRAM
Atmiņas ka grafikas karšu kontrole.
Tāpēc mēs saucam šo funkciju SDL_CreateTextureFromSurface.
Mēs arī tā mūsu attēlotājs un mūsu virsmu.
Un tad mēs esam patiesībā darīts ar virsmu,
tāpēc mēs esam tikai gatavojas atbrīvot to.
Mums nav nepieciešams to vairs.
Un tad tā, ja šis zvans errored un atgriezās null,
tad mēs esam gatavojas darīt visu kļūda atkal ziņošanas lieta.
>> Viss kārtībā.
Lūk, mēs nokļūt kādu faktiskie izciršanas funkcijas.
Tātad zvanot SDL_RenderClear un iet to
attēlotājs, kas saistīti ar mūsu logu vienkārši padara logu iet melns.
Tātad, tas noņem ka junk, ka mēs redzējām Mūsu logs pirms un padara to melns.
Un tad mēs ejam zvanīt SDL_RenderCopy,
arī tā mūsu attēlotājs, mūsu tekstūru.
Un mēs runājam par to, ko Šie lauki ir mazliet.
Bet kas notiek, lai ņemt tekstūra dati
un kopēt to uz mūsu logu izdarīt attēlu.
Tātad, kad mēs esam darījuši šo eksemplāru datus uz mūsu loga,
mums ir jādara šo papildu funkciju sauc SDL_RenderPresent.
>> Un tas ir interesanti jo tas izpaužas
par tēmu sauc dubultā buferizācija.
Tātad dubultā buferizācijas ir tehnika, kas padara jūsu grafikas izskatās daudz labāk.
Atkal, tas novērš šo ekrānu pārplēst Es runāju par agrāk, kur
jums ir divi buferi.
Tur ir atpakaļ bufera atmiņa un priekšējais buferis.
Priekšējais buferis ir burtiski kas ir uz ekrāna brīdī.
Tātad mēs visi šie izdarīt variācijas, tāpat SDL padarīt kopiju vai SDL_RenderClear
uz muguras bufera.
Tāpēc viņi mainīt lietas aizmugurējā buferī.
Šeit mēs varētu šo zīmējumu zaļš kvadrātveida uz muguras bufera.
>> Tāpēc tad, kad mēs esam darījuši darām Mūsu padara darbības, kas
var aizņemt ļoti ilgu laiku laiks, ko mēs gatavojamies darīt
ir slēdzis buferi.
Tātad, tas burtiski vienkārši ņem priekšējais buferis un atpakaļ buferis
un slēdži tos, tāpēc ka, uzreiz,
vienas operācijas laikā, tā vietā, lai varbūt simtiem vai tūkstošiem,
visi mūsu nesen padarīti objekti ir uz ekrāna.
Un tas novērš lietas piemēram, ekrāna atsvaidzinošu
kad mēs esam tikai sagatavots puse Mūsu objektu rāmja.
Tātad, tāpēc mums ir nepieciešams, lai izsauktu SDL_RenderPresent, kā arī
kā SDL_RenderCopy.
>> Atgādināsim, ka mēs esam tikai gatavojas gaidīt piecas sekundes.
Tad mēs ejam sakopt mūsu resursus.
Mums ir diezgan maz vairāk šoreiz.
Un tad mēs esam tikai gatavojas lai izietu no programmas.
Tātad, pieņemsim darīt.
Es esmu gatavojas rakstīt izdarīt, un tad avotus vienāds hello-- tas tagad 3image.c.
Labi, ka apkopoti bez kļūdām.
Un jūs varat redzēt šeit es esmu tagad izvilkta manu attēlu, Hello, CS50!
mūsu loga, kas izzūd pēc piecām sekundēm.
>> Tagad, tas joprojām ir problēmas, vai ne?
Tas nav labs pieteikums, jo, kad es mēģināt, lai aizvērtu logu,
nekas nenotiek.
Ka x ir joprojām nav reaģēt.
Tātad pieņemsim ieskatieties Nākamais failu, hello4animation.
Tātad šis ir fails kas notiek, lai ieviestu
aizkustinoša un kustība uz mūsu tēlu.
Tāpēc mēs esam gatavojas darīt pats kā iepriekš,
uzsākt SDL, izveidotu logu, izveidot attēlotājs,
ielādēt attēlu atmiņa, izveidot tekstūru.
Mēs esam redzējuši visu, kas pirms tam.
Tagad tas ir jauns.
Mēs ejam, lai ir struktūra, ko sauc SDL rect, kas ir tikai taisnstūris.
Ja mēs ejam nekā šeit, mēs varam do meklēt SDL RECT,
un jūs varat redzēt, ka tas ir ļoti vienkārša struktūra.
Tā ir X, Y, lai stāvoklis, un tas
ir platākas un augstumu izmērs taisnstūra.
>> Tātad, ko mēs gatavojamies darīt, ir, mēs esam gatavojas definēt šo SDL Rect Dest,
par galamērķi.
Un šī ir vieta uz ekrāna, kur
mēs ejam, lai būtu zīmēšanas Mūsu attēlu, labi So
ja mēs gribam būt kustīgu attēlu apkārt,
tad galamērķis, kur mēs spēsim izdarīt attēlu
nepieciešams pārvietojas.
Tātad mēs ejam, lai izsauktu šo funkcija SDL_QueryTexture.
Un paziņojums es esmu iet adresi no dest.w, kas ir platums,
un dest.h, kas ir augstums.
Un tā SDL_QueryTexture notiek uzglabāt šajās jomās platums
un augstums mūsu tekstūras.
>> Un tad ko es esmu gatavojas to darīt, ir es eju
noteikt dest.x būt logu platums mīnus dest.w, kas ir
platums elfa, dalīts ar 2.
Un tas notiek, lai uzstādītu to uz augšu, lai ka attēls ir pilnīgi centrēts
mūsu logā, labi?
Tāpēc tagad man ir y pozīciju.
Un tas būs būt mainīga, kas ir
mainās, jo mēs ejam, lai būtu kustīgu attēlu y virzienā.
Un tagad mums ir kaut kas sauc animācijas cilpa.
>> Tātad, kā tas animācija darbojas?
Nu, cilvēka acs var atklāt 12 atšķirīgas attēlus katru sekundi, labi?
Tātad, ja jūs flash 12 attēlu kārtis uz mani sekundē, es redzēju katru no šiem attēliem
kā savu atšķirīgu individuālo tēlu.
Tagad, ja jūs flash vairāk attēlus uz mani sekundē,
tad manu acu sāktos izzust kopā
un es varētu uztvert to kā kustības, nevis viena atsevišķa attēla.
Tātad, piemēram, filmas un televīzijas, mirgo attēlus jums 24 reizes
otrs.
Tātad tas ir 24 kadriem sekundē.
Datoru ekrāni, no otras puses, bieži vien ir pie 60 kadriem sekundē.
Tas ir viņu atsvaidzināt ātrums.
Tas, cik bieži viņi atsvaidzināt attēlu uz ekrāna.
Tātad mūsu mērķis būs 60 kadri sekundē, kas ir mūsu spēles.
>> Tātad, pieņemsim redzēt, ka kodu.
Tātad katram kadram, mēs vispirms gatavojas notīrītu logu.
Tas ir vispārējs modelis.
Jūs vienmēr skaidrs logs katra rāmja, un pēc tam
darīt visu savu zīmējumu operāciju, un pēc tam beigās,
do RenderPresent parādīt viss kadrā.
Un tad jūs gatavojas ir jāgaida beigās
jāgaida līdz nākamajai rāmis jāsāk.
>> Tātad, ja man bija darīt daudz sarežģīts aprēķins šeit
kas notika vairāk nekā 16 milisekundes, nebūtu iespējams par mani
lai iegūtu šo kadru ātrumu 60, kas Es gribēju, jo katrs kadrs ir
ņemot pārāk ilgi, lai aprēķinātu.
Turklāt, mēs tiešām darām kārtot niecīgu darba apjomu
šeit, jo tur ir tikai viena lieta, ko mēs esam zīmējumu.
Tāpēc es tikai jāgaida 1/60 kādas otrkārt, kas ir garums
no rāmja starp kadriem.
Tāpēc es esmu veida izliekoties darīt viss mans darbs aizņem nulles laiku.
Bet reālā spēlē, jūs ir atņemt
daudz laika pagāja darīt viss šis darbs no jūsu atpūtas laiku.
>> Tātad vienalga, ko es esmu faktiski dara šajā cilpa?
Es notīrīt logu.
Es noteikti dest.y, kas ir int mana aktuālā y amats iemesta int.
Tagad, es gribu peldēt rezolūciju manu y stāvokli manu spēli,
bet tad faktiski izdarīt to uz ekrāna,
tai Ints, jo tas ir vienībās pikseļi, tā ka tas, ko cast ir.
Es esmu gatavojas izdarīt attēlu.
Tātad šis ir avots taisnstūris.
Un tas ir galamērķis taisnstūris.
Tāpēc es pagājis null par avots taisnstūris
teikt, es gribu vērst visu manu tekstūru.
Bet, ja jums bija daudz tekstūras jūsu spēli
un viņi visi vienā lielā tekstūras kartē kas tika iepildīta SDL kā tikai viens
tekstūra, jūs varētu izmantot avota taisnstūri
izvēlēties vienu no mazākiem faktūru, viens no mazākajiem sprites,
no šīs lielās tekstūras kartē.
>> Tātad vēlreiz, es esmu iet manu padarīt, mana tekstūra, un tagad galamērķis.
Tas būs tā, kurā logu tas būs jāizdara.
Un tad, jo es esmu apguve kaut kas, man vajag kustību,
Es esmu būs atjaunināšanu elfa nostāja par katru rāmja.
Tāpēc man ir šī konstante sauc rulli paātrināt vienībās pikseļu sekundē.
Tagad, katru reizi, kad mēs to kustību, rāmis ir tikai 1/60 daļa no sekundes.
Tāpēc es esmu gatavojas sadalīt, ka līdz 60.
Un tad, pieņemsim redzēt, es esmu atskaitot ka no y pozīcijas.
Kāpēc es esmu atņemot?
Mēs sāksim ka sekundē.
Tātad es sakopt savus resursus un programma ir beigusies.
>> Tātad, pieņemsim darīt, ka.
Tātad pieņemsim iedziļināties make SRCS = hello4 animation.c, labi?
Spēle.
Lūdzu.
Tāpēc man ir tas ritinot augšup logs, kas ir diezgan veikls.
Bet tur, es tika atņemot no y stāvoklī katru reizi.
Kas notiek tur?
Nu, izrādās, ka SDL, un Patiesībā, vairumā datorgrafikā,
izcelsme par koordinātu sistēmu ir augšējā kreisajā stūrī loga.
>> Tātad pozitīvais x virziens iet pāri jūsu loga pa labi.
Un pozitīvā y virziens faktiski iet uz leju.
Tātad vēlreiz, izcelsmi ir in augšējā kreisajā stūrī jūsu loga,
pozitīvs y virziens ir uz leju, un pozitīvs x ir pa labi.
Tātad, kad es atņemt no y pozīcija, kas ir
gatavojas, lai tas iet uz negatīvo Y virzienā, kas ir atkarīgs no loga.
Tātad tas, kas notiek tur.
Cool.
>> Apskatīsim nākamo failu.
Šeit ir daļa no parādīt, kur mēs beidzot
iegūt, ka X stūrī loga kas ir paredzēts, lai aizvērtu logu
strādāt.
Tātad, kas notiek?
Mēs sāktu SDL, izveidot logu, izveidot attēlotājs, slodze attēlu,
izveidot faktūru piemēram, mēs esam redzējuši iepriekš.
Mums ir tāda pati mērķa taisnstūri kā iepriekš, tas pats aicinājums vaicājumu tekstūru.
Bet šoreiz, mēs esam tam gatavojas sadalīt platumu
un augstums mūsu galamērķa 4.
Tas ir tikai sekas mērogošana mūsu attēlu uz leju, kad
mēs parādītu to logā ar četri.
Tātad tas ir diezgan veikls.
Mēs varam tikai mērogu tieši tāpat.
Mēs ejam, lai sāktu Sprite centrā ekrāna.
Un tagad mums ir X un Y ātrumu un viņi abi gatavojas sākt no nulles.
>> Tas ir nepareizs fails.
Man ir žēl.
Tā ka viss ir taisnība.
Tas viss vēl šajā failā.
Mums ir plaisu 4. un viss.
Tātad šeit mums ir X un Y pozīciju par centrā loga.
Un mēs arī tā sākotnējo ātrumu Šīs konstantu ātrumu, kas
Es uzskatu, ka ir 300 pikseļi sekundē.
Tagad mums ir tas int varētu tikpat labi būt Būla sauc tuvu pieprasīts.
Un tā vietā, darot bezgalīga cilpa uz taimeri šeit,
mēs spēsim tikt apguve kā Kamēr tuvu nav pieprasīta.
>> Tātad, kā mēs apstrādājam notikumus?
Nu, SDL rindas up notikumus gramatisko rinda aizkulisēs.
Un tad katrs kadrs, mēs varam dequeue notikumus
No šīs rindas, izmantojot šis aicinājums SDL_PullEvent.
Un atkal, noteikti iet lasīt par to dokumentācijā.
Tur ir daudz vairāk detaļu un daudz vairāk funkcijas jūs varat izmantot ar to.
Mums iet tā adrese Šī lieta, SDL_Event
ka mēs esam šeit uz skursteņa.
>> Tagad, kas ir SDL_event?
Jo SDL, ja mēs skatāmies tad documentation-- pieņemsim
skat, API pa kategorijām, ievadi notikumi, notikumu apstrādi,
mēs varam apskatīt numuru dažādu pasākumu šeit
un mēs varam redzēt tur ir vesela ton no tiem.
Tātad, kas tas ir SDL_Event lieta?
SDL_Event ir savienība.
Wow, kas ir savienība?
Jūs esat droši vien nekad dzirdējis, ka pirms.
Un tas ir OK.
>> Arodbiedrības ir veids kā struct, izņemot struct
ir telpu visiem tā lauki un atmiņa,
tā kā savienība ir tikai pietiekami daudz vietas, lai ietilptu lielākā
viens no tās lietošanas jomu, kas nozīmē, ka tas var saglabāt tikai vienu no tās laukiem
laikā, kas veida jēga pasākumiem, vai ne?
Mēs varam būt tastatūra notikums vai logs notikums,
bet viens notikums nevar būt gan tastatūra notikums un logu notikums,
tāpēc lūdzu būt muļķīgi ir vieta abi no tiem iekšā mūsu notikumu savienību.
Tātad, ja jūs vēlaties, lai izveidot savu savienību,
tas izskatās tieši tāds pats kā izveidot struct,
izņemot to, ka mēs izmantojam Eiropas Savienības atslēgvārdu nevis struct atslēgvārdu.
Un atceries, lai visi lietas iekšpusē jūsu savienību,
faktiskais mainīgais, kas ir savienība var būt tikai viena no tām vērtībām
laikā.
>> Tātad, kā mēs varam pateikt, kāda veida notikums mēs tikko popped off šo rindā?
Nu, mēs varam pārbaudīt, lai event.type.
Un, ja tas ir vienāds līdz SDL_Quit, mēs zinām,
tas ir notikums, kas tika radīts, kad mēs
hit, ka X stūrī loga.
Un mēs varam noteikt tuvu pieprasīta ir vienāds ar 1.
Pārējais ir tikai dažas animācijas ka jūs esat redzējis.
So iesim uz priekšu un padarīt šo un redzēt, cik labi tā darbojas.
Tāpēc es esmu gatavojas rakstīt marku un tad SRCS = hello5_events.c.
Tur mēs ejam.
Spēles.
>> Tagad mēs varam redzēt, tas bija patiešām samazināts līdz četriem.
Un tagad tas ir veselīgs apkārt.
Man ir dažas sadursmes atklāšana notiek ar loga malas
ka mēs varam to apskatīt.
Un kas notiek, kad es iet to aizvērt?
Tas aizveras.
Fantastic.
Mēs esam saņēmuši šo notikumu.
Un mēs to jārīkojas.
>> Tātad pieņemsim atskatīties uz kodu.
Tātad, kā man to veselīgs apkārt, piemēram, ka?
Atcerieties, es noteikti gan X un y sākotnēji ātrumu.
Un ātrums ir pozitīvs nemainīgs, tā ka ir
dodas, lai saņemtu to, sākot out iet uz leju un pa labi.
>> Tagad, katrs rāmis, papildus apstrādi notikumi, kas varētu būt noticis,
Es esmu gatavojas atklāt, vai manu elfa mēģina iziet no loga.
Tātad, mēs varam darīt, ka, tikai pārbaudot x_pos ar 0, y_pos 0, un pēc tam
arī x_pos un y_pos ar loga platums un augstums logu.
Paziņojums Es esmu atņemti platums elfa.
Un tas ir tāpēc, ka, ja man nav atņemt platums elfa,
tas tikai pārbaudīt, izcelsmi elfa
negāja aiz loga.
Bet mēs gribam visu vielas platums elfa
lai vienmēr iekšpusē loga un visa augstums elfa
lai vienmēr iekšpusē loga.
Tātad, tas ko atņemšanu ir.
Daudz ģeometrijas šeit var būt noderīgi izdarīt to ārā
uz papīra ar koordinātu sistēma, lai redzētu, kas notiek.
>> Tātad, ja es saduras, es tikko vienkārši reset pozīciju
tā, ka tas nav iet no ekrāna.
Un es esmu gatavojas, ja tas bounces uz vienas no sānu sienām,
Es esmu gatavojas noliegt x ātrums tā, ka tas
sākas veselīgs citā virzienā.
Un līdzīgi, ja tas hits augšējā vai apakšējā,
Es esmu gatavojas noteikt y ātrumu vienāds ar negatīvu y ātrumu,
tā, ka tas piepeši atpakaļ.
Tātad tas ir tikai, kā mēs saņēmām, ka šeit.
>> Un atjaunināšana pozīcijas tāpat kā mēs esam redzējuši iepriekš,
izdalot ar 60, jo mēs esam tikai apstrādes 1/60 sekundes.
Un tad izciršanas, tieši tāds pats kā pirms tam.
Un tā tas ir viss kas notiek šajā lietā.
Tātad tas, kā mēs to darām notikumus.
Galvenais atņemt šeit tas SDL_PullEvent funkcija.
Un jums noteikti vajadzētu izlasīt dokumentācija vairāk par SDL_Event
savienību, jo šis datu tips ir ļoti, ļoti svarīgi, jo mēs to izmantot
visa veida notikumiem.
>> Piemēram, mēs to izmantot tastatūras notikumi, kas ir tas, ko šis fails ir.
Tātad, ko mēs esam?
Mums ir tas pats kā iepriekš, sāktu SDL, izveidot logu,
izveidot attēlotājs, ielādēt attēlu atmiņā, izveidot tekstūru.
Atgādināsim, ka mēs spēsim ir šī dest taisnstūri,
mēs ejam mēroga attēlu četri, padarīt to nedaudz mazāks.
Tagad mēs gatavojamies sākt elfa centrā ekrāna.
Bet šoreiz, mēs ejam, lai iestatītu sākotnējie x un y ātrumi līdz nullei,
jo tastatūra ir gatavojas kontrolēt tos.
Un turklāt, mēs ejam, lai sekot šiem mainīgajiem
uz augšu, uz leju, pa kreisi un pa labi.
Un kas notiek, lai saglabātu dziesmu par to, vai mēs esam
nospiests tastatūras pogas, kas atbilst uz augšu, uz leju, pa kreisi,
un pa labi.
>> Tagad, tas ir sava veida iedomātā jo mēs varam izmantot W, A, S,
D šeit, vai faktiskie bulttaustiņus.
Mēs redzam, ka tikai sekundi.
Tātad mēs ejam, lai apstrādātu notikums, tāpat kā līdz šim.
Mēs pull notikumu.
Bet tagad mēs spēsim pāriet uz notikuma veidu.
Ja tas ir SDL_Quit, mēs esam gatavojas noteikt aizvērt
lūdza vienam, tāpat kā līdz šim.
Kas rokturi X stūrī loga,
lai mūsu logs faktiski aizveras.
>> Pretējā gadījumā, ja mēs iegūtu SDL taustiņu uz leju notikums, kas nozīmē, ka mēs nospiedis taustiņu,
tad ko mēs gatavojamies darīt, ir, mēs esam gatavojas pāriet uz šo lietu šeit,
kas means-- tik event.key nozīmē ārstēt mūsu notikumu savienību,
iet un saņemt atslēgu notikums struktūra tajā.
Tātad izrādās, ka šis savienība ir svarīgs notikums struktūra.
Un tad iet uz atslēgu Pasākuma struktūra tā lauks
sauc keysym un tad scancode.
Un atkal, noteikti izlasīt dokumentācija par šo.
Atslēgvārds ieejas diezgan interesants.
Jūs varat iegūt skenēšanas kodiem vai galvenos kodus.
Un tas ir mazliet smalks, bet dokumentācija ir diezgan laba.
>> Tātad, ja mēs redzam, skenēšanas kodu Mūsu galvenais prese ir W vai uz augšu,
mēs spēsim izveidot vienāds ar 1.
Un tad mēs izkļūt no šīs slēdzi.
Ja tas ir vai pa kreisi, mēs, kas atstāta 1, et tā tālāk, un tā tālāk, uz leju un pa labi.
Tagad, šajā ārējā slēdzi, ja mēs redzam taustiņu uz augšu notikumu,
tas nozīmē, ka mēs esam izlaiduši atslēga un mēs vairs nospiežot to.
Tāpēc es esmu gatavojas teikt up ir 0, kreisā ir 0, noteikti ir vienāds ar 0, pa labi
ir 0, un tā tālāk.
>> Un paziņojums mums ir katrā no šiem divi gadījumi likt blakus viens otram
bez atsevišķu kodu par pirmajā gadījumā, kas
nozīmē, ka tas, vai tā ir S vai uz leju tieši šeit,
tas notiek, lai izpildītu šo kodu.
Tātad tas ir diezgan parocīgs.
Tas novērš mums, kam to darīt vairāk nosacījumus un IFS un lietas
tāpat.
>> Tātad mēs ejam noteiktu ātrumu.
Mēs noteikti ātrumu līdz 0.
Tad, ja līdz tiek nospiests un ne uz leju, tad mēs
noteikt y ātrumu uz negatīvu ātrumu.
Atcerieties negatīva, jo negatīvs y virziens ir uz augšu.
Un pozitīvā y virziens ir uz leju.
Ja uz leju tiek nospiests un nevis uz augšu, tad mēs esam
gatavojas noteikt to uz pozitīvu ātrumu, kas nozīmē iet uz leju ekrānu.
Pats ar kreiso un labo.
>> Un tad mēs ejam, lai atjauninātu pozīcijas tāpat kā pirms tam.
Mēs darīsim sadursmi atklāšana ar robežas,
bet mēs nebrauksim, lai atjaunotu ātrums, jo ātrums ir tikai
kontrolē klaviatūru.
Bet mēs gribam, lai atjaunotu pozīcijas, lai saglabātu to loga.
Un mēs ejam, lai iestatītu pozīcijas uz struct
un tad darīt visu padarot stuff no iepriekš.
Tātad, pieņemsim redzēt, ko tā dara.
Tātad, lai SRCS-- pieņemsim redzēt, tas ir hello6_keyboard.c.
>> Ak, nē.
Tātad, mēs saņēmām dažus brīdinājumus šeit.
Un tas ir vienkārši sakot, mēs neesam pārbaudīt katru iespējamo veidu
par notikumu.
Tas ir OK, jo tur ir 236 no viņiem, vai arī tā.
Tāpēc es esmu gatavojas ignorēt šos brīdinājumus.
Tas joprojām ir apkopota naudas sodu.
Tāpēc es esmu gatavojas spēlēt spēli.
Tas nav kustībā.
Bet tagad, kad es misu uz manu klaviatūru, Es varu darīt daži WASD kustību šeit,
Es izmantot savu bulttaustiņus, kā arī.
Un paziņojums, lai gan es esmu nospiežot tiesības tieši tagad,
tas nav dodas ārā pa logu, jo es reset to katrā kadrā.
Tātad tas ir diezgan veikls.
Jūs varat iedomāties, pārvietojoties ar Mario daži bulttaustiņus vai kaut kas tamlīdzīgs.
Un jā, tad X strādā.
>> Tāpēc galīgais fails mēs ejam apskatīt, hellow7_mouse.
Tas ir par kļūst peles ievadi.
Tātad šo vienu, mēs importēt math galvenes,
jo mēs esam nāksies mazliet math šeit.
Pats vecais, tas pats vecais sīkumi, galamērķis, tas pats vecais, redzams, ka pirms tam.
Nu, tas ir interesanti.
Tātad mēs esam atpakaļ tikai pārbaudot par SDL atmest notikumu.
Kāpēc ir tā, ka?
Tātad jūs varat saņemt peles ievadi no notikumiem.
Tāpat, kad pele pārvietot, jums notikumu par to.
Kad peles poga tiek nospiesta, jūs varat iegūt notikumu par to.
>> Bet tur ir cita, nedaudz vienkāršāka varbūt, API, lai iegūtu peles ievadi.
Un tas ir vienkārši SDL get pele valsts.
Tāpēc man ir int X un y par kursora pozīciju.
Es nodot to SDL_GetMouseState, kas nosaka šos.
Un tas ir pozīcija koordinātu sistēmā no loga.
Tātad, ja masa ir augšējā kreisajā loga, kas būtu 0, 0.
>> Tagad, ko es esmu gatavojas darīt, ir es eju darīt mazliet vektora math.
I bet jūs domāju, ka tu negribēji redzam, ka CS50, bet šeit tas ir.
Es esmu gatavojas darīt kādu vektors math, lai iegūtu vektoru
no attēla kursora.
Un tad kāpēc man ir šī atņemšana šeit?
Nu, ja es tikai izmantot Dest .-- tik Man vajag, lai tulkot peles x
un y ar ½ no platuma un augstums attēla,
jo es gribu centrā attēls, kas iet uz peli,
ne izcelsme attēla.
>> Tātad tas ir tikai, lai pārliecinātos, ka es runāju par attēla centram šeit.
Tad mēs delta x un y, kas ir atšķirība no mērķa
faktiskajam stāvoklim attēla.
Un tad mēs varam iegūt attālums šeit, kas
būs Pitagora teorēma, kvadrātsakne no X
reizes x plus y reizes y.
>> Tagad, lai novērstu nervozēt, un es varu parādīt tu ko tas dara, ja man nav to izdarītu,
ja attālums starp kursora un attēls centrs ir mazāks nekā pieci,
Es esmu tikai nav gatavojas pārvietot attēlu.
Pretējā gadījumā mēs noteikti ātrumu.
Un mēs, kas to tā, ka ātrums vienmēr būs nemainīga.
Un neto rezultāts no visiem šī matemātika ir tas, ka attēla
gatavojas pāriet uz kursora.
>> Tagad, izrādās, ka SDL_GetMouseState,
papildus iestatot x un y argumentus šeit,
tas arī atgriež int, kas atbilst uz stāvokli peles pogas.
Tātad mēs nevaram izlasīt, ka tieši, bet mēs varam
izmantot šos makro, viena Bitu līmeņa uzņēmējs, nav tik biedējošu,
tikai Bitu līmeņa un.
Tātad mēs sakām pogas, kas ir rezultāts Mūsu SDL_GetMouseState, ja tas
un Bitu līmeņa un šis makro šeit, SDL_BUTTON_LEFT.
>> Tātad tas būs vienkārši atrisināt uz bitkarte kas atbilst
uz kreiso peles pogu nospiešanu.
Un tā, ja Bitu līmeņa un notiek, un tas ir
nav nulle, un tas nozīmē, kreisi poga tika nospiesta,
tad mēs patiešām gatavojas noliegt gan x un y ātrumi,
kas tikai padara attēlu Runaway.
Atjaunināt pozīcijas.
Sadursmju atklājumi, to redzējuši viss pirms, padarot, viss labi.
Padarīsim to.
Tātad jums veikt SRCS = hello7_mouse.c.
Liels.
Nav kļūdas.
Un spēle.
>> Tātad, šeit man ir manu peli.
Un attēls ir patiešām pakaļdzīšanās manu peli.
Tagad spēlē jūs veicat, varbūt Tas ir kā ienaidnieka pakaļdzīšanās
jūsu maz raksturs vai neatkarīgi.
Bet šeit mums ir attēls pakaļdzīšanās peli.
Un, kad es noklikšķiniet, peles sākas pakaļdzīšanās attēlu
un attēls ir bēgšana no peli.
Tātad tas ir diezgan forši.
Un paziņojums atkal, tur ir joprojām sadursmes atklāšanas šeit.
>> Tā, ka ir pēdējais maz demo Man ir izveidotas šeit.
Un pieņemsim to apskatīt vēl viena lieta.
Tātad atpakaļ šeit, es minēju šo nervozēt.
Viss kārtībā.
Tātad, ja attālums ir mazāks nekā pieci pikseļi, Es rietot X un Y ātrumu līdz nullei.
Kas notiek, ja mēs atbrīvoties no tā?
Tāpēc es esmu gatavojas vienkārši izdarīt.
Lūdzu, atvainojiet šo šausminošos stilu, bet mēs komentēja out pareizo kodu.
Tāpēc es esmu gatavojas, lai saglabātu to un darīt pats komandu no agrāk, lai padarītu to.
>> Viss kārtībā.
Un tagad, kas notiek?
Labs.
Mēs joprojām seko pele tāpat kā līdz šim,
bet, kad mēs nokļūt peli, mēs esam ieguvuši šo bruto nervozēt.
Kas notiek tur?
Nu, mūsu vektors math, atcerieties, mēs bijām
ņemot vērā attālumu starp kursors un attēla centrā?
Nu, kā tas tuvojas 0, sākam saņemt
patīk šāda veida traks uzvedības ja attēls ir sava veida
tāpat svārstīgas ap kursoru.
Un, kas ir radīt šo nervozēt.
Un tas tiešām neglīts.
Un jūs, iespējams, nav vēlaties, lai jūsu spēles dara, ka,
ja vien tas ir sava īpaša iedarbība veida.
>> Tātad, tāpēc mēs esam tikai šo patvaļīgs
nogriezts no piecām pikseļi, kur mēs sakām ja tas ir piecu pikseļi, mēs esam labi.
Mums nevajag, lai pārvietotu attēlu vairs.
Tātad tas, kas notiek tur.
>> Tātad tas ir diezgan daudz to.
Jūs tagad zināt, kā izveidot logs, slodze attēlu,
zīmēt attēlu uz loga, iegūt tastatūru, iegūt peles ievadi,
tur ir ķekars citu ievade, ka jums nebūs
zināt, kā iegūt, ja jūs vienkārši pavadīt Dažas minūtes skatās dokumentāciju.
Tātad jūs faktiski ir diezgan daži instrumenti jūsu rīcībā tagad
uzrakstīt pilnvērtīgu spēli.
>> Tagad, katru spēli vajadzīgas dažas audio, bet audio dokumentācija
ir arī diezgan labs.
Un es esmu gatavs derēt, ka, ja jūs saprotat visas lietas
mēs runājām par šodien ar attēlus, un virsmas,
logiem, un viss, tad norādītas audio API nav
būs tik slikti.
Tāpēc es ceru redzēt Ko jums izveidot ar SDL.