Share
Aflați elementele de bază ale funcției FlashPunk - o bibliotecă uimitoare care vă va economisi timp și vă va ajuta să creați jocul perfect!
Să aruncăm o privire la rezultatul final la care vom lucra:
Utilizați tastele săgeți pentru a muta personajul tău (tipul albastru). Tipul roșu / brun este un NPC; zona roșie umbrită este o zonă periculoasă, iar caseta verde este un buton. Veți învăța cum să creați toate acestea în acest tutorial.
FlashPunk este o bibliotecă ActionScript 3 creată pentru dezvoltarea jocurilor Flash. Practic, aceasta face toată munca grea pentru dvs. și vă permite să vă concentrați în întregime pe dezvoltarea jocului dvs., mai degrabă decât pe motorul din spatele acestuia. Cea mai bună parte este că nu aveți nevoie de Flash Pro pentru a lucra cu acesta: puteți face totul cu un editor de cod gratuit, cum ar fi FlashDevelop. Să nu mai vorbim că este mult mai rapid atunci când vine vorba de a desena lucrurile pe ecran, deoarece folosește blitting!
Acest tutorial va trece prin toate elementele de bază ale FlashPunk. După ce îl urmăriți, veți fi gata să faceți un joc simplu cu această bibliotecă uimitoare!
Începeți prin descărcarea ultimei versiuni FlashPunk de pe site-ul oficial (acest tutorial utilizează versiunea din 30 august 2011). Puneți folderul "net", cu tot conținutul acestuia, în dosarul "src".
FlashPunk are o clasă numită Motor. Această clasă este ceea ce începe totul în bibliotecă. Gândește-te la asta ca la Principal dar cu cod special pentru a activa toate clasele din FlashPunk. Pentru a utiliza Motor clasa, vom modifica Principal clasa un pic.
pachet import net.flashpunk.Engine; [Frame (factoryClass = "Preloader")] clasa publică Extensia principală Motor funcția publică Main (): void
Acum, clasa noastră se extinde Motor. În Principalconstructor, trebuie să sunăm la Motor constructor: acesta este ceea ce stabilește informațiile importante despre joc: lățimea, înălțimea, framerate și dacă motorul ar trebui să ruleze la un cadru fix sau nu.
funcție publică (): void super (550, 400, 30, false);
Există o funcție care poate (și trebuie să fie) anulată de la Motor clasa: init () funcţie. Acesta va rula doar o singură dată și va inițializa totul pentru ca jocul să funcționeze.
Accentsconagua
suprascrie funcția publică init (): void trace ("Jocul a început!"); Sunt destul de sigur că toată lumea vrea să pună ceva pe ecran și să vadă acest motor funcționează! Din această cauză, următorii câțiva pași vor acoperi foarte elementele de bază ale elementelor FlashPunk, adăugând adâncimea pe măsură ce tutorialul merge mai departe.
În FlashPunk, există elemente numite lumi și entităţile. Acestea sunt principalele elemente ale bibliotecii și veți lucra cu ele de la începutul până la sfârșitul jocului.
Lumile sunt aproape la fel ca ceea ce este cunoscut sub numele de "ecran". Totul în joc se va întâmpla într-o lume: meniul principal este o lume care vă va oferi acces la lumea de joc real, în cazul în care vă va lupta niște dușmani și mor, care vă va duce la joc peste mondial, cu scoruri dumneavoastră și statistici despre cât de bine ai făcut-o. Mai multe despre lumi vor fi explicate mai târziu.
Entitățile sunt exact ceea ce par a fi; ei trăiesc într-o lume și fac ceva în ea: un buton este o entitate; caracterul tău este o entitate; dușmani și gloanțe sunt entități. Acestea sunt lucrurile care dau viață jocului.
Având în vedere că vom crea lumea jocurilor (este timpul să facem mai târziu meniul principal al lumii, să trecem la o acțiune!) Prin extinderea gamei FlashPunk Lume clasă:
pachet import net.flashpunk.World; clasa publică GameWorld extinde lumea funcția publică GameWorld ()
Acum că ați creat o lume, trebuie să-i spuneți lui FlashPunk că doriți ca această lume să fie cea activă. Să facem asta Main.as:
privat var _gameWorld: GameWorld; funcție publică (): void super (550, 400, 30, false); _gameWorld = nou joc (); suprascrie funcția publică init (): void trace ("Jocul a început!"); FP.world = _gameWorld; Și nu uitați să importați net.flashpunk.FP!
Acum, că avem lumea noastră, putem face o entitate prin extinderea Entitate clasă și adăugându-l în lumea noastră de joc:
pachet import net.flashpunk.Entity; clasa publică GameEntity extinde Entitatea funcția publică GameEntity ()
Si in GameWorld.as:
privat var _gameEntity: GameEntity; funcția publică GameWorld () _gameEntity = nou jocEntity (); add (_gameEntity);
Observați că dacă compilați și rulați jocul, entitatea nu apare pe ecran. Asta pentru ca nu are nicio imagine! Fiecare entitate poate avea un obiect grafic. Acest grafic poate fi o singură imagine, o foaie de sprite cu animații, imagini din ceramică - cam nimic.
Vom adăuga această imagine mică entității noastre:
Graficele entității pot fi accesate de către grafic proprietate. Așa vom pune imaginea în ea! Mai întâi, încorporați-o; apoi, dă-i drumul Imagineconstructorul și FlashPunk vor avea grijă să transforme asta în ceva vizibil pentru tine. Compilați și rulați acum. Surprinde! Entitatea noastra este acolo!
pachet import net.flashpunk.Entity; import net.flashpunk.graphics.Image; clasa publica GameEntity extinde Entitatea [Embed (sursa = "/? /img/EntityImage.png")] privat const IMAGE: Class; funcția publică GameEntity () graphic = new Image (IMAGE);
Aceasta este ceea ce ar trebui să obțineți:
Acum că avem entitatea noastră pe ecran, cum rămâne cu mutarea? Fiecare Entitate are o funcție numită Actualizați(), pe care trebuie să o înlocuiți pentru a le utiliza. Această funcție este numită de fiecare lume la începutul fiecărui cadru. Dacă trebuie să faceți mutarea entității dvs., acesta este locul unde ați pus codul!
suprascrie actualizarea funcției publice (): void x + = 10 * FP.elapsed; y + = 5 * FP; elapsed;
Și nu uitați să importați:
import net.flashpunk.FP;
Vezi-o în acțiune! (Actualizați pagina dacă nu vedeți nimic aici).
S-ar putea să fi observat utilizarea lui FP.elapsed. FP.elapsed dă timpul care a trecut de la ultimul cadru (în secunde), ceea ce face foarte ușor să se creeze mișcarea bazată pe timp. Cu toate acestea, pentru ca aceasta să funcționeze, trebuie să fi setat al patrulea parametru la Motorconstructorul lui fals. Amintiți-vă că (Pasul 2)? Setarea la fals înseamnă că doriți ca FlashPunk să ruleze cu un interval de timp variabil, în timp ce setați-l la Adevărat face ca FlashPunk să ruleze pe un interval de timp fix. Făcând acest lucru, nu trebuie să îl folosiți FP.elapsed. Veți ști că de fiecare dată Actualizați() funcția se numește, a trecut un cadru.
În ultima etapă, entitatea se mișcă într-o singură direcție. Introducerea intrărilor de la tastatură: acum veți putea să mutați entitatea acolo unde doriți!
FlashPunk are o clasă numită Intrare care are grijă de intrarea tastaturii și a mouse-ului. În acest tutorial, vom folosi numai intrarea tastaturii pentru mișcare. Este foarte ușor:
suprascrie actualizarea funcției publice (): void if (Input.check (Key.A) || Input.check (Key.LEFT)) x - = 50 * FP.elapsed; altceva dacă (Input.check (Key.D) || Input.check (Key.RIGHT)) x + = 50 * FP.elapsed; dacă (Input.check (Key.W) || Input.check (Key.UP)) y - = 50 * FP.elapsed; altceva dacă (Input.check (Key.S) || Input.check (Key.DOWN)) y + = 50 * FP.elapsed;
Iar declarațiile de import:
import net.flashpunk.utils.Input; import net.flashpunk.utils.Key;
Input.check () se intoarce Adevărat dacă Cheie trecut ca un argument este presat la momentul în care funcția a fost numit. Există și alte funcții foarte utile, cum ar fi Input.pressed (), care se întoarce Adevărat dacă tasta a fost apăsată la momentul apelării funcției (adică cheia a fost în sus cu un cadru în urmă și este acum în jos) sau Input.released (), care face exact opusul.
Un alt lucru interesant că Intrare clasa ne permite să facem este să definim mai multe chei sub un singur nume. De exemplu, am putea defini Key.UP, Key.W și Key.I la fel de "SUS", și verificați numai pentru Input.check ( "UP"). În acest fel, ne putem îmbunătăți funcția:
funcția publică GameEntity () graphic = new Image (IMAGE); Input.define ("UP", Key.W, Key.UP); Input.define ("DOWN", Key.S, Key.DOWN); Input.define ("LEFT", Key.A, Key.LEFT); Input.define ("DREAPTA", Key.D, Key.RIGHT); suprascrie actualizarea funcției publice (): void if (Input.check ("LEFT")) x - = 50 * FP.elapsed; altfel dacă (Input.check ("DREAPTA")) x + = 50 * FP.elapsed; dacă (Input.check ("UP")) y - = 50 * FP.elapsed; altfel dacă (Input.check ("DOWN")) y + = 50 * FP.elapsed; Și asta ar trebui să obțineți:
Entitățile pot face mult mai mult decât să se miște în jur și să aibă imagini. Să aruncăm o privire la surprinderile pe care le pot ține!
Entitățile au o proprietate numită tip. Puteți seta această proprietate la orice șir doriți. Acest lucru vă permite să vă organizați entitățile în grupuri, ceea ce se va dovedi foarte util în următorul pas (despre lumi). Putem, de exemplu, să setăm tipul entității noastre la "GameEntity":
funcția publică GameEntity () graphic = new Image (IMAGE); Input.define ("UP", Key.W, Key.UP); Input.define ("DOWN", Key.S, Key.DOWN); Input.define ("LEFT", Key.A, Key.LEFT); Input.define ("DREAPTA", Key.D, Key.RIGHT); type = "GameEntity"; În continuare, avem util lume proprietate și adăugat() și îndepărtat() funcții. lume proprietatea vă permite să accesați lumea din interiorul codului entității odată ce entitatea a fost adăugată unei lumi. Este ca și etapă proprietate în dezvoltarea comună Flash; funcțiile sunt ca și ADDED_TO_STAGE și REMOVED_FROM_STAGE ascultători de evenimente. Iată un exemplu de funcții care funcționează în GameEntity.as:
suprascrie funcția publică adăugată (): void trace ("entitatea a fost adăugată lumii!"); urmări ("Entitățile din lume:" + contul mondial); suprascrie funcția publică eliminată (): void trace ("entitatea a fost eliminată din lume!"); Este timpul să priviți mai profund lumile și modul în care acestea funcționează. În primul rând, FlashPunk poate avea doar o singură lume care rulează simultan, dar jocul dvs. poate avea cât mai multe lumi pe cât doriți, atâta timp cât numai unul rămâne activ de fiecare dată.
Lumile au Actualizați() funcționează la fel ca entitățile, dar funcția lor este puțin diferită: în codul actual există cod Lume clasă. Asta înseamnă că va trebui să suni super.update () de fiecare dată când înlocuiți această funcție.
În afară de entități, lumile pot, de asemenea, să aibă grafică adăugat la ele. Grafica sunt imagini care nu trebuie să fie actualizate de dvs. (FlashPunk creează încă o entitate care să le adauge în lume, astfel încât motorul va trimite un apel către un Actualizați() funcţie). Puteți să le adăugați prin apelare addGraphic ().
Cel mai important lucru despre lumi este că au mai multe funcții pentru a prelua anumite entități: gettype (), getClass (), ia tot(), getLayer () și getInstance (). În acest fel, puteți să reveniți la o gamă largă de gloanțe din joc, astfel încât să puteți efectua o verificare împotriva tuturor pentru coliziune. Foarte la îndemână, trebuie să spun!
Uitați-vă la codul adăugat la World.as. Vom folosi și oa doua imagine:
[Embed (sursă = "/? /Img/EntityImage2.png")] privat const IMAGE: Class; funcția publică GameWorld () _gameEntity = nou jocEntity (); add (_gameEntity); addGraphic (imagine nouă (IMAGE), 0, 50, 50); suprascrie actualizarea funcției publice (): void super.update (); var entitateArray: Array = []; getType ("GameEntity", entityArray); pentru fiecare (entitate var: Entitate în entityArray) entity.x = entity.x> 550? 550: entity.x; entity.y = entity.y> 400? 400: entity.y; Și nu uitați să importați net.flashpunk.graphics.Image!
În acest cod, addGraphic () funcția de apel adaugă o altă grafică similară cu _gameEntity's grafice - gândiți-vă la ea ca un NPC! - lumii în poziție (50, 50). Liniile 23-31 arată un exemplu de recuperare a unor entități de un anumit tip: sunăm gettype () pentru a obține numai entități de tip "GameEntity" (în prezent, doar o singură entitate). După aceasta, vom repeta toate entitățile recuperate și le vom împiedica să treacă peste frontierele drepte și inferioare. (Deci, entitatea se poate mișca în afara ecranului, dar nu departe.) Simplu, nu-i așa??
Timp pentru ceva mai interesant! FlashPunk acceptă animații de toate felurile. Tot ce trebuie să faceți este să nu creați o instanță Imagine, creați un exemplu de Spritemap. Această clasă primește o foaie de sprite și vă permite să cartografiați cadre și să vă conectați la animații.
În clasa entității noastre, încorporați acest spritemap:
Apoi, creați un exemplu de Spritemap și să treacă foaia de sprite ca parametru pentru constructor. După aceea, este vorba de a apela adăuga() și Joaca() funcții!
[Embed (sursă = "/? /Img/EntitySheet.png")] privat const SHEET: Class; privat var _timeInterval: Număr; funcția publică GameEntity () graphic = nou Spritemap (SHEET, 40, 20, onAnimationEnd); Spritemap (grafic) .add ("Oprit", [0]); Spritemap (grafic) .add ("Clipește", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 24); Input.define ("UP", Key.W, Key.UP); Input.define ("DOWN", Key.S, Key.DOWN); Input.define ("LEFT", Key.A, Key.LEFT); Input.define ("DREAPTA", Key.D, Key.RIGHT); type = "GameEntity"; Spritemap (grafic) .play ( "intermitent"); funcția privată onAnimationEnd (): void Spritemap (grafic) .play ("Oprit"); _timeInterval = 0; suprascrie actualizarea funcției publice (): void _timeInterval + = FP.elapsed; dacă (_timeInterval> = 3) Spritemap (grafic) .play ("Clipește"); dacă (Input.check ("STÂNGA")) x - = 50 * FP.elapsed; altfel dacă (Input.check ("DREAPTA")) x + = 50 * FP.elapsed; dacă (Input.check ("UP")) y - = 50 * FP.elapsed; altfel dacă (Input.check ("DOWN")) y + = 50 * FP.elapsed; Constructorul Spritemap (linia 19) are patru argumente: o sursă pentru a obține un grafic, lățimea și înălțimea fiecărui cadru al foii de sprite și o funcție de apel invers pentru a apela când se termină animația (opțional). În GameEntityconstructorul, creăm Spritemap și defini două animații: "Oprit", care conține doar primul cadru și rulează la 0 fps (oprit!) și "Clipește", care conține toate cadrele și rulează la 24 de cadre pe secundă.
Restul codului este acolo pentru a reda animația "Clipește" la fiecare trei secunde.
Uitați-vă la entitatea care clipește:
Cu totul să meargă bine, este timpul să introducem o altă caracteristică: detecția coliziunilor. FlashPunk are un sistem de detecție a coliziunilor: tot ce trebuie să facem este să punem la dispoziția entităților noastre hitbox-uri și să cerem lumii să verifice coliziunile. Pentru aceasta, vom crea o altă entitate numită Cutie care va conține următoarea grafică:
pachet import net.flashpunk.Entity; import net.flashpunk.graphics.Image; public clasa Box extinde Entitatea [Embed (source = "/? /img/BoxImage.png")] privat const IMAGE: Class; funcția publică funcțională () graphic = new Image (IMAGE); setHitbox (60, 60);
Și înăuntru GameWorld.as:
privat var _box: Box; funcția publică GameWorld () _gameEntity = nou jocEntity (); _box = caseta nouă (); add (_gameEntity); add (_box); _box.x = 200; _box.y = 150; addGraphic (imagine nouă (IMAGE), 0, 50, 50);
setHitbox () funcția stabilește un dreptunghi care va acționa ca o casetă de lovitură pentru entitate. Primii doi parametri sunt lățimea și înălțimea casetei. Următorii doi parametri (opțional) sunt coordonatele de origine (x și y) ale dreptunghiului. Faceți același lucru pentru GameEntity:
funcția publică GameEntity () graphic = nou Spritemap (SHEET, 40, 20, onAnimationEnd); Spritemap (grafic) .add ("Oprit", [0]); Spritemap (grafic) .add ("Clipește", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 24); Input.define ("UP", Key.W, Key.UP); Input.define ("DOWN", Key.S, Key.DOWN); Input.define ("LEFT", Key.A, Key.LEFT); Input.define ("DREAPTA", Key.D, Key.RIGHT); type = "GameEntity"; Spritemap (grafic) .play ( "intermitent"); setHitbox (40, 20); Acum că avem atât entitatea noastră, cât și cutia creată cu hitbox-uri, trebuie să verificăm coliziunile din clasa mondială:
suprascrie actualizarea funcției publice (): void super.update (); var entitateArray: Array = []; getType ("GameEntity", entityArray); pentru fiecare (entitate var: Entitate în entityArray) entity.x = entity.x> 550? 550: entity.x; entity.y = entity.y> 400? 400: entity.y; dacă (_gameEntity.collideWith (_box, _gameEntity.x, _gameEntity.y)) trace ("Coliziune!"); a se ciocni cu() funcția verifică coliziunea cu entitatea trecută ca argument, plasând practic prima entitate (în acest caz, _gameEntity) în poziția specificată de argumentele al doilea și al treilea.
Odată ce o coliziune este detectată, trebuie să existe un răspuns la aceasta. Vom schimba numai poziția entității mobile:
suprascrie actualizarea funcției publice (): void super.update (); var entitateArray: Array = []; getType ("GameEntity", entityArray); pentru fiecare (entitate var: Entitate în entityArray) entity.x = entity.x> 550? 550: entity.x; entity.y = entity.y> 400? 400: entity.y; dacă (_gameEntity.collideWith (_box, _gameEntity.x, _gameEntity.y)) _gameEntity.x = _gameEntity.y = 0; Uitați-vă la exemplu. Încercați să mutați entitatea în cutie.
FlashPunk nu are în mod implicit niciun buton. Aproape toate jocurile au nevoie de butoane, deci în acest pas vom crea un a Buton clasă. Mai întâi de toate, un buton are trei stări (după cum probabil știți din dezvoltarea Flash comună): "Sus", "Peste" și "Jos". Această fișă spritesc ilustrează faptul că:
Și acum să începem clasa:
pachet import net.flashpunk.Entity; import net.flashpunk.graphics.Spritemap; butonul public clasa extinde Entitatea protejat var _map: Spritemap; funcția publică funcție (x: număr = 0, y: număr = 0) super (x, y); funcția publică setSpritemap (element: *, cadruW: uint, frameH: uint): void _map = nou Spritemap (activ, frameW, frameH); _map.add ("Sus", [0]); _map.add ("Peste", [1]); _map.add ("Down", [2]); graphic = _map; setHitbox (cadruW, cadruH); suprascrie funcția publică rendering (): void super.render (); setSpritemap () funcția stabilește un template pentru buton și stabilește "animații" pentru buton. Întotdeauna imaginea trebuie să aibă mai întâi cadrul "Up", apoi "Over", urmat de cadrul "Down". Există și un apel către setHitbox (). Blocul de afișări va fi folosit pentru a verifica dacă mouse-ul este sau nu este peste caseta butonului.
Acum, când afișează cu succes Butonul nostru, este momentul să creați controale de sus și jos. Vom face acest lucru creând două atribute booleene: "peste" și "clic". Vom detecta, de asemenea, dacă mouse-ul se află peste butonul de lovire al butonului sau nu. Adăugați aceste funcții în Button.as:
protejat var _over: Boolean; protejat var _clicked: Boolean; suprascrie actualizarea funcției publice (): void if (! world) return; _over = false; _clicked = false; dacă (collidePoint (x - world.camera.x, y - world.camera.y, Input.mouseX, Input.mouseY)) if (Input.mouseDown) mouseDown (); altceva mouseOver (); funcția protejată mouseOver (): void _over = true; funcția protejată mouseDown (): void _clicked = true; suprascrie funcția publică rendere (): void if (_clicked) _map.play ("Down"); altfel dacă (_over) _map.play ("Peste"); altceva _map.play ("Sus"); super.render (); Și nu uitați să importați net.flashpunk.utils.Input.
Urmând logica din Actualizați(): în primul rând, ambele atribute (_clicked și _peste) sunt setate la false. După aceasta, verificăm dacă mouse-ul este deasupra butonului. Dacă nu, atributele vor rămâne false și butonul va fi în starea "Up". Dacă mouse-ul se termină, verificăm dacă butonul mouse-ului este în prezent în jos. Dacă este adevărat, butonul se află în starea "Jos" și _clicked este setat la true; dacă este falsă, atunci butonul se află în starea "Peste" și _peste atributul este setat la true. Aceste atribute vor defini cadrul în care ar trebui să meargă spritemap.
Acest buton va fi inutil dacă nu puteți detecta când utilizatorul a făcut clic efectiv. Să schimbăm puțin clasa pentru a susține funcțiile de apel invers:
protejat var _callback: Funcție; protejat var _argument: *; funcția publică funcția (apel invers: funcție, argument: *, x: număr = 0, y: număr = 0) super (x, y); _callback = apel invers; _argument = argument; suprascrie actualizarea funcției publice (): void if (! world) return; _over = false; _clicked = false; dacă (collidePoint (x - world.camera.x, y - world.camera.y, Input.mouseX, Input.mouseY)) if (Input.mouseReleased) clicked (); altfel dacă (Input.mouseDown) mouseDown (); altceva mouseOver (); funcția protejată clicked (): void if (! _argument) _callback (); altceva _callback (_argument);
Butonul nostru este gata! Acest cod vă va permite să transmiteți butonului o funcție de apel invers (și, opțional, un argument), de fiecare dată când utilizatorul face clic pe buton, funcția va fi apelată.
Mulți pași și nimic pe ecran? E timpul să puneți un buton acolo! Este la fel de simplu ca adăugarea acestui cod în GameWorld.as:
[Embed (sursă = "/? /Img/ButtonSheet.png")] private const BUTTONSHEET: Clasă; buton privat var: buton; funcția publică GameWorld () _gameEntity = nou jocEntity (); _box = caseta nouă (); butonul = buton nou (onButtonClick, null); _button.setSpritemap (BUTTONSHEET, 50, 40); add (_gameEntity); add (_box); add (_button); _box.x = 200; _box.y = 150; _button.x = 400; _button.y = 200; addGraphic (imagine nouă (IMAGE), 0, 50, 50); funcția privată onButtonClick (): void FP.screen.color = Math.random () * 0xFFFFFF; urmări ("Apăsați butonul!"); Acum tot ce trebuie să faceți este să compilați proiectul și butonul va fi acolo!
Și acum caracteristica finală de la FlashPunk, care va fi prezentat în acest tutorial! Consolă este instrumentul Flashpunk pentru depanare: dispune de jurnale, care sunt destul de mult ca urme; arată timpul necesar derulării unui pas important al motorului; și afișează câte entități sunt pe ecran și FPS curent. Este un instrument minunat de utilizat atunci când vă dezvoltați jocul. Pentru ao activa, trebuie doar să adăugați următoarea linie Main.as:
suprascrie funcția publică init (): void trace ("Jocul a început!"); FP.console.enable (); FP.world = _gameWorld; Și pentru a înregistra orice în ea, utilizați FP.log () funcţie. De exemplu, să schimbăm asta urmă() apel:
suprascrie funcția publică init (): void FP.console.enable (); FP.log ("Jocul a început!"); FP.world = _gameWorld; Cam asta e tot! Veți vedea că partea "Ieșire" din consola de depanare arată acum jurnalul. Puteți merge și schimbați toate urmă() sună în codul nostru la apelurile către FP.log ().
Aceasta este introducerea noastră în FlashPunk, care acoperă cele mai importante aspecte ale acestei uimitoare biblioteci: entități, lumi, imagini și animații; coliziune, butoane, intrare și mișcare. Sper că veți dori această bibliotecă la fel de mult ca mine - chiar face munca mai ușoară!
