Share
Leer de basis van hoe FlashPunk werkt - een geweldige bibliotheek om u tijd te besparen en u te helpen het perfecte spel te maken!
Laten we eens kijken naar het eindresultaat waar we naartoe zullen werken:
Gebruik de pijltjestoetsen om je karakter te verplaatsen (de blauwe kerel). De rood / bruine man is een NPC; het gearceerde rode gebied is een gevarenzone en het groene vakje is een knop. Je leert hoe je dit allemaal kunt maken in deze tutorial.
FlashPunk is een ActionScript 3-bibliotheek die is gemaakt voor de ontwikkeling van Flash-games. Kortom, het doet al het harde werk voor je en laat je je volledig richten op het ontwikkelen van je spel, in plaats van op de motor erachter. Het mooie hiervan is dat je Flash Pro niet nodig hebt om ermee te werken: je kunt alles doen met een gratis code-editor zoals FlashDevelop. Om nog te zwijgen van het is veel sneller als het gaat om het tekenen van dingen op het scherm, omdat het gebruik van blitting!
Deze tutorial doorloopt alle basisprincipes van FlashPunk. Na het te hebben gevolgd, bent u klaar om een eenvoudige game te maken met deze geweldige bibliotheek!
Begin met het downloaden van de nieuwste versie van FlashPunk vanaf de officiële site (deze tutorial gebruikt de versie van 30 augustus 2011). Zet de "net" map, met al zijn inhoud, in uw "src" map.
FlashPunk heeft een klasse genaamd Motor. Deze klasse begint alles in de bibliotheek. Zie het als een Hoofd klasse, maar met speciale code om alle klassen in FlashPunk op te starten. Om de. Te gebruiken Motor klasse, we zullen de Hoofd les een beetje.
pakket import net.flashpunk.Engine; [Frame (factoryClass = "Preloader")] public class Main extends Engine public function Main (): void
Nu gaat onze klas verder Motor. In Hoofd's constructor, we moeten bellen naar de Motor constructor: dit is wat de belangrijke informatie over het spel bepaalt: width, height, framerate en of de engine moet draaien met een vaste framerate of niet.
public function Main (): void super (550, 400, 30, false);
Er is een functie die kan worden (en moet) worden opgeheven door de Motor klasse: de in het() functie. Het wordt maar één keer uitgevoerd en zal alles initialiseren om de game te laten werken.
Accentsconagua
override public function init (): void trace ("The game is started!"); Ik ben er vrij zeker van dat iedereen iets op het scherm wil zetten en deze motor wil laten werken! Daarom zullen de volgende paar stappen de basisprincipes van de elementen van FlashPunk bestrijken, en diepte toevoegen als de zelfstudie doorgaat..
In FlashPunk worden elementen genoemd S werelds en entiteiten. Dit zijn de belangrijkste elementen van de bibliotheek, en je zult ermee werken vanaf het begin tot het einde van je spel.
Werelden lijken veel op wat algemeen bekend staat als een "scherm". Alles in je spel zal in een wereld gebeuren: het hoofdmenu is een wereld die je toegang zal geven tot de eigenlijke spelwereld, waar je tegen sommige vijanden vecht en sterft, wat je naar de game over de wereld zal leiden, met je scores en statistieken over hoe goed je het deed. Meer over werelden zal later worden uitgelegd.
Entiteiten zijn precies wat ze lijken te zijn; ze leven in een wereld en doen er iets in: een knop is een entiteit; je karakter is een entiteit; vijanden en kogels zijn entiteiten. Het zijn de dingen die het spel leven.
Gegeven dat we de gamewereld zullen creëren (er is tijd om de wereld van het hoofdmenu later te maken, laten we naar een actie springen!) Door FlashPunk's uit te breiden Wereld klasse:
pakket import net.flashpunk.World; public class GameWorld breidt World uit openbare functie GameWorld ()
Nu je een wereld hebt gecreëerd, moet je FlashPunk vertellen dat je wilt dat deze wereld de actieve is. Laten we het doen Main.as:
privé var _gameWorld: GameWorld; public function Main (): void super (550, 400, 30, false); _gameWorld = nieuwe GameWorld (); override public function init (): void trace ("The game is started!"); FP.world = _gameWorld; En vergeet niet te importeren net.flashpunk.FP!
Nu we onze wereld hebben, kunnen we een entiteit vormen door de Entiteit klasse en voeg het toe aan onze gamewereld:
pakket import net.flashpunk.Entity; public class GameEntity breidt Entity uit openbare functie GameEntity ()
En in GameWorld.as:
privé var _gameEntity: GameEntity; publieke functie GameWorld () _gameEntity = new GameEntity (); toe te voegen (_gameEntity);
Merk op dat als je het spel compileert en uitvoert, de entiteit niet op het scherm verschijnt. Dat komt omdat het nog geen beeld heeft! Elke entiteit kan een grafisch object hebben. Deze afbeelding kan een enkele afbeelding zijn, een spritesheet met animaties, betegelde afbeeldingen - vrijwel alles.
We zullen dit kleine plaatje toevoegen aan onze entiteit:
De afbeelding van een entiteit kan worden geopend door de grafisch eigendom. Dat is hoe we het beeld erin gaan plaatsen! Eerst insluiten; geef het dan gewoon door aan Beeld's constructor en FlashPunk zorgen ervoor dat je dat verandert in iets dat voor jou zichtbaar is. Compileer en ren nu. Verrassing! Onze entiteit is er!
pakket import net.flashpunk.Entity; import net.flashpunk.graphics.Image; public class GameEntity breidt Entity uit [Embed (source = "/? /img/EntityImage.png")] private const IMAGE: Class; openbare functie GameEntity () graphic = new Image (IMAGE);
Dit is wat je zou moeten krijgen:
Nu we onze entiteit op het scherm hebben staan, hoe zit het dan met het verplaatsen ervan? Elk Entiteit heeft een functie genaamd bijwerken(), die je moet negeren om te gebruiken. Deze functie wordt door elke wereld aan het begin van elk frame genoemd. Als u uw entiteit moet laten bewegen, is dat de plaats waar u uw code plaatst!
override public function update (): void x + = 10 * FP.elapsed; y + = 5 * FP.elapsed;
En vergeet niet om te importeren:
import net.flashpunk.FP;
Zie het in actie! (Ververs de pagina als u hier niets ziet.)
U hebt misschien het gebruik van gemerkt FP.elapsed. FP.elapsed geeft de hoeveelheid tijd die is verstreken sinds het laatste frame (in seconden), waardoor het heel eenvoudig is om op tijd gebaseerde bewegingen te maken. Om dat te laten werken, moet u de vierde parameter echter hebben ingesteld op Motor's constructor van vals. Onthoud dat (stap 2)? Instellen op vals betekent dat u FlashPunk wilt laten werken met een variabele tijdspanne, terwijl u dit wilt instellen waar maakt FlashPunk op een vaste tijdspanne draaien. Als u het laatste doet, hoeft u het niet te gebruiken FP.elapsed. Je zult dat elke keer weten dat het bijwerken() functie wordt aangeroepen, een frame is gepasseerd.
We hebben de entiteit in de laatste stap maar in één richting. Introductie van toetsenbordinvoer: nu kunt u de entiteit naar waar u wilt verplaatsen!
FlashPunk heeft een klasse genaamd Invoer die zorgt voor zowel toetsenbord- als muisinvoer. In deze zelfstudie gebruiken we alleen toetsenbordinvoer voor beweging. Het is heel makkelijk:
override publieke functie update (): void if (Input.check (Key.A) || Input.check (Key.LEFT)) x - = 50 * FP.elapsed; else if (Input.check (Key.D) || Input.check (Key.RIGHT)) x + = 50 * FP.elapsed; if (Input.check (Key.W) || Input.check (Key.UP)) y - = 50 * FP.elapsed; else if (Input.check (Key.S) || Input.check (Key.DOWN)) y + = 50 * FP.elapsed;
En de importstatements:
import net.flashpunk.utils.Input; import net.flashpunk.utils.Key;
Input.check () komt terug waar als het Sleutel geslaagd als een argument wordt ingedrukt op het moment dat de functie is aangeroepen. Er zijn andere zeer nuttige functies, zoals Input.pressed (), welke terugkeert waar als de toets is ingedrukt op het moment dat de functie werd aangeroepen (dat wil zeggen de sleutel was een frame geleden omhoog en is nu naar beneden), of Input.released (), wat precies het tegenovergestelde doet.
Een ander interessant ding dat de Invoer klasse stelt ons in staat om veel sleutels onder één naam te definiëren. We zouden bijvoorbeeld kunnen definiëren Key.UP, Key.W en Key.I zoals "UP", en controleer alleen voor Input.check ( "UP"). Op die manier kunnen we onze functie verbeteren:
openbare functie 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 ("RIGHT", Key.D, Key.RIGHT); overschrijven openbare functie-update (): void if (Input.check ("LEFT")) x - = 50 * FP.elapsed; else if (Input.check ("RIGHT")) x + = 50 * FP.elapsed; if (Input.check ("UP")) y - = 50 * FP.elapsed; else if (Input.check ("DOWN")) y + = 50 * FP.elapsed; En dit is wat u zou moeten krijgen:
Entiteiten kunnen veel meer doen dan alleen rondlopen en afbeeldingen hebben. Laten we eens kijken welke verrassingen ze kunnen bevatten!
Entiteiten hebben een eigenschap genaamd type. U kunt deze eigenschap instellen voor elke gewenste reeks. Hiermee kun je je entiteiten indelen in groepen, wat heel nuttig zal blijken in de volgende stap (over werelden). We kunnen bijvoorbeeld het type van onze entiteit instellen op "GameEntity":
openbare functie 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 ("RIGHT", Key.D, Key.RIGHT); type = "GameEntity"; In aansluiting daarop hebben we het nuttige wereld- eigendom en de toegevoegd () en verwijderd () functies. De wereld- property biedt u toegang tot de wereld vanuit de code van de entiteit zodra de entiteit aan een wereld is toegevoegd. Het is als het stadium eigendom gemeenschappelijk Flash-ontwikkeling; de functies zijn als de ADDED_TO_STAGE en REMOVED_FROM_STAGE gebeurtenis luisteraars. Hier is een voorbeeld van de functies die werken in GameEntity.as:
override public function added (): void trace ("De entiteit is aan de wereld toegevoegd!"); trace ("Entiteiten in de wereld:" + world.count); override public function removed (): void trace ("De entiteit is van de wereld verwijderd!"); Het is tijd om werelden en hoe ze werken dieper te bekijken. Allereerst kan FlashPunk slechts één wereld tegelijkertijd laten draaien, maar je game kan zoveel werelden hebben als je wilt, zolang er maar één actief blijft elke keer.
Werelden hebben bijwerken() werkt net als entiteiten, maar hun functie is een beetje anders: er is echte code in de Wereld klasse. Dat betekent dat je moet bellen super.update () elke keer dat u deze functie overschrijft.
Los van entiteiten kunnen werelden ook hebben grafiek toegevoegd aan hen. Afbeeldingen zijn afbeeldingen die niet door u hoeven te worden bijgewerkt (FlashPunk maakt nog steeds een entiteit om ze aan de wereld toe te voegen, dus de motor zal nog steeds een oproep naar een bijwerken() functie). Je kunt ze toevoegen door te bellen addGraphic ().
Het belangrijkste van werelden is dat ze verschillende functies hebben om bepaalde entiteiten op te halen: getType (), getClass (), alles krijgen(), getLayer () en getInstance (). Op die manier kun je de wereld een reeks van alle kogels laten retourneren die momenteel in het spel zitten, zodat je ze allemaal kunt controleren op een botsing. Heel handig, moet ik zeggen!
Bekijk de code die is toegevoegd aan World.as. We zullen ook een tweede afbeelding gebruiken:
[Embed (source = "/? /Img/EntityImage2.png")] private const IMAGE: Class; publieke functie GameWorld () _gameEntity = new GameEntity (); toe te voegen (_gameEntity); addGraphic (nieuwe afbeelding (IMAGE), 0, 50, 50); override public function update (): void super.update (); var entityArray: Array = []; getType ("GameEntity", entityArray); voor elke (var-entiteit: Entiteit in entityArray) entity.x = entity.x> 550? 550: entity.x; entity.y = entity.y> 400? 400: entity.y; En vergeet niet te importeren net.flashpunk.graphics.Image!
In deze code, de addGraphic () functieaanroep voegt een andere afbeelding toe die lijkt op _gameEntityis grafisch - zie het als een NPC! - naar de wereld in de positie (50, 50). Regel 23-31 tonen een voorbeeld van het ophalen van alleen entiteiten van een bepaald soort: we call getType () om alleen entiteiten van het type "GameEntity" te krijgen (momenteel slechts één entiteit). Hierna herhalen we elke opgehaalde entiteit en voorkomen ze dat ze de juiste en onderste grenzen passeren. (Dus, de entiteit kan buiten het scherm bewegen, maar niet ver.) Eenvoudig, nietwaar?
Tijd voor iets interessants! FlashPunk ondersteunt allerlei soorten animaties. Het enige dat je hoeft te doen is, in plaats van het creëren van een instantie van Beeld, maak een instantie van Spritemap. Deze klasse ontvangt een sprite-sheet en stelt u in staat om frames in een lijst te plaatsen en naar animaties te linken.
In de klasse van onze entiteit, embed deze spritemap:
Maak vervolgens een instantie van Spritemap en geef het spritesheet door als parameter aan de constructor. Daarna draait alles om het bellen van de toevoegen() en spelen() functies!
[Embed (source = "/? /Img/EntitySheet.png")] private const BLAD: Klasse; private var _timeInterval: Number; openbare functie GameEntity () graphic = new Spritemap (SHEET, 40, 20, onAnimationEnd); Spritemap (grafisch) .add ("Gestopt", [0]); Spritemap (grafisch) .add ("Knipperen", [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 ("RIGHT", Key.D, Key.RIGHT); type = "GameEntity"; Spritemap (grafische) .play ( "Knipperende"); private function onAnimationEnd (): void Spritemap (graphic) .play ("Stopped"); _timeInterval = 0; override public function update (): void _timeInterval + = FP.elapsed; if (_timeInterval> = 3) Spritemap (graphic) .play ("Knipperen"); if (Input.check ("LEFT")) x - = 50 * FP.elapsed; else if (Input.check ("RIGHT")) x + = 50 * FP.elapsed; if (Input.check ("UP")) y - = 50 * FP.elapsed; else if (Input.check ("DOWN")) y + = 50 * FP.elapsed; De aannemer van Spritemap (regel 19) neemt vier argumenten: een bron om een afbeelding van te krijgen, de breedte en hoogte van elk frame van het sprite-blad en een callback-functie om te bellen wanneer de animatie eindigt (optioneel). In GameEntity's constructor, we maken de Spritemap en definieer twee animaties: "Gestopt", die alleen het eerste frame bevat en draait op 0 fps (stopped!) en "Blinking", dat alle frames bevat en met 24 frames per seconde wordt uitgevoerd.
De rest van de code is daar om de "knipperende" animatie elke drie seconden af te spelen.
Bekijk onze entiteit knipperend:
Omdat alles goed loopt, is het tijd om een nieuwe functie te introduceren: botsingsdetectie. FlashPunk heeft een groot botsingsdetectiesysteem: we hoeven alleen maar hitboxes in te stellen voor onze entiteiten en de wereld te vragen om te controleren op botsingen. Daarvoor zullen we een andere entiteit creëren genaamd Doos welke de volgende afbeelding zal bevatten:
pakket import net.flashpunk.Entity; import net.flashpunk.graphics.Image; public class Box breidt Entity uit [Embed (source = "/? /img/BoxImage.png")] private const IMAGE: Class; openbare functie Box () graphic = new Image (IMAGE); setHitbox (60, 60);
En van binnen GameWorld.as:
private var _box: Box; publieke functie GameWorld () _gameEntity = new GameEntity (); _box = nieuwe Box (); toe te voegen (_gameEntity); toe te voegen (_box); _box.x = 200; _box.y = 150; addGraphic (nieuwe afbeelding (IMAGE), 0, 50, 50);
De setHitbox () functie stelt een rechthoek in die als een hokje voor de entiteit fungeert. De eerste twee parameters zijn de breedte en hoogte van de doos. De volgende twee parameters (optioneel) zijn de coördinaten van de oorsprong (x en y) van de rechthoek. Doet hetzelfde voor GameEntity:
openbare functie GameEntity () graphic = new Spritemap (SHEET, 40, 20, onAnimationEnd); Spritemap (grafisch) .add ("Gestopt", [0]); Spritemap (grafisch) .add ("Knipperen", [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 ("RIGHT", Key.D, Key.RIGHT); type = "GameEntity"; Spritemap (grafische) .play ( "Knipperende"); setHitbox (40, 20); Nu we zowel onze entiteit als de box hebben ingesteld met hitboxes, moeten we controleren op botsingen in de wereldklasse:
override public function update (): void super.update (); var entityArray: Array = []; getType ("GameEntity", entityArray); voor elke (var-entiteit: Entiteit in entityArray) entity.x = entity.x> 550? 550: entity.x; entity.y = entity.y> 400? 400: entity.y; if (_gameEntity.collideWith (_box, _gameEntity.x, _gameEntity.y)) trace ("Collision!"); De botsen met() functie controleert botsing met de entiteit doorgegeven als een argument, virtueel de eerste entiteit plaatsen (in dit geval, _gameEntity) in de positie gespecificeerd door het tweede en derde argument.
Zodra een botsing is gedetecteerd, moet er een reactie op zijn. We veranderen alleen de positie van de bewegende entiteit:
override public function update (): void super.update (); var entityArray: Array = []; getType ("GameEntity", entityArray); voor elke (var-entiteit: Entiteit in entityArray) entity.x = entity.x> 550? 550: entity.x; entity.y = entity.y> 400? 400: entity.y; if (_gameEntity.collideWith (_box, _gameEntity.x, _gameEntity.y)) _gameEntity.x = _gameEntity.y = 0; Bekijk het voorbeeld. Probeer de entiteit in het vak te verplaatsen.
FlashPunk heeft standaard geen knoppen. Bijna alle games hebben knoppen nodig, dus in deze stap zullen we een Knop klasse. Allereerst heeft een knop drie toestanden (zoals je misschien weet uit de gemeenschappelijke Flash-ontwikkeling): "Omhoog", "Over" en "Omlaag". Dit spritesheet illustreert dat:
En laten we nu beginnen met de klas:
pakket import net.flashpunk.Entity; import net.flashpunk.graphics.Spritemap; openbare klasse Knop breidt Entiteit uit beschermd var _map: Spritemap; openbare functie Knop (x: Getal = 0, y: Getal = 0) super (x, y); public function setSpritemap (item: *, frameW: uint, frameH: uint): void _map = new Spritemap (asset, frameW, frameH); _map.add ("Omhoog", [0]); _map.add ("Over", [1]); _map.add ("Omlaag", [2]); graphic = _map; setHitbox (frameW, frameH); override public function render (): void super.render (); De setSpritemap () functie stelt een spritemap voor de knop in en stelt "animaties" in voor de knop. Het beeld moet altijd eerst het "Omhoog" -kader hebben, dan het "Boven", gevolgd door het "Omlaag" -kader. Er is ook een oproep voor setHitbox (). De hitbox wordt gebruikt om te controleren of de muis zich wel of niet boven de knop bevindt.
Nu we hebben dat onze knop een afbeelding goed laat zien, is het tijd om de besturingselementen omhoog, boven en onder te maken. We zullen het doen door twee Booleaanse attributen te creëren: "over" en "geklikt". We zullen ook detecteren of de muis zich boven de hitbox van de knop bevindt of niet. Voeg deze functies toe in Button.as:
beschermd var _over: Boolean; beschermd var _clicked: Boolean; override public function update (): void if (! world) return; _over = false; _clicked = false; if (collidePoint (x - world.camera.x, y - world.camera.y, Input.mouseX, Input.mouseY)) if (Input.mouseDown) mouseDown (); else mouseOver (); beschermde functie mouseOver (): void _over = true; beschermde functie mouseDown (): void _clicked = true; override public function render (): void if (_clicked) _map.play ("Down"); else if (_over) _map.play ("Over"); else _map.play ("Up"); super.render (); En vergeet niet te importeren net.flashpunk.utils.Input.
De logica volgen in bijwerken(): ten eerste, beide attributen (_clicked en _over) zijn ingesteld op false. Daarna controleren we of de muis over de knop is. Als dat niet het geval is, blijven de kenmerken onwaar en staat de knop in de "Omhoog" -status. Als de muis klaar is, controleren we of de muisknop op dat moment is ingedrukt. Als dat waar is, staat de knop in de "Down" -status en _clicked is ingesteld op waar; als het vals is, dan staat de knop in de "Over" -status en de _over attribuut is ingesteld op true. Deze attributen zullen bepalen naar welk frame de spritemap moet gaan.
Deze knop is nutteloos als u niet kunt detecteren wanneer de gebruiker erop heeft geklikt. Laten we de klasse een beetje wijzigen om callback-functies te ondersteunen:
beschermd var _callback: functie; beschermd var _argument: *; publieke functie Knop (callback: functie, argument: *, x: Number = 0, y: Number = 0) super (x, y); _callback = callback; _argument = argument; overschrijven openbare functie-update (): void if (! world) return; _over = false; _clicked = false; if (collidePoint (x - world.camera.x, y - world.camera.y, Input.mouseX, Input.mouseY)) if (Input.mouseReleased) geklikt (); else if (Input.mouseDown) mouseDown (); else mouseOver (); beschermde functie geklikt (): void if (! _argument) _callback (); else _callback (_argument);
Onze knop is klaar! Met deze code kunt u een callback-functie (en optioneel een argument) doorgeven aan uw knop, dus wanneer de gebruiker op de knop klikt, wordt de functie gebeld.
Veel stappen en niets op het scherm? Tijd om daar een knop te plaatsen! Het is zo simpel als het toevoegen van deze code GameWorld.as:
[Embed (source = "/? /Img/ButtonSheet.png")] private const BUTTONSHEET: Klasse; private var _button: Knop; publieke functie GameWorld () _gameEntity = new GameEntity (); _box = nieuwe Box (); _button = nieuwe knop (onButtonClick, null); _button.setSpritemap (BUTTONSHEET, 50, 40); toe te voegen (_gameEntity); toe te voegen (_box); toe te voegen (_button); _box.x = 200; _box.y = 150; _button.x = 400; _button.y = 200; addGraphic (nieuwe afbeelding (IMAGE), 0, 50, 50); private function onButtonClick (): void FP.screen.color = Math.random () * 0xFFFFFF; trace ("Er is op de knop geklikt!"); Nu hoef je alleen nog maar het project te compileren en de knop zal daar zijn!
En nu de laatste functie van FlashPunk die in deze tutorial zal worden gepresenteerd! De Troosten is de tool van FlashPunk voor foutopsporing: het bevat logboeken, die lijken op sporen; toont de tijd die nodig is om een belangrijke motorstap uit te voeren; en geeft weer hoeveel entiteiten op het scherm staan en de huidige FPS. Het is een geweldige tool om te gebruiken bij het ontwikkelen van je game. Om het in te schakelen, voegt u gewoon de volgende regel toe aan Main.as:
override public function init (): void trace ("The game is started!"); FP.console.enable (); FP.world = _gameWorld; En om iets in te loggen, gebruik de FP.log () functie. Laten we daar bijvoorbeeld verandering in brengen spoor() bellen:
override public function init (): void FP.console.enable (); FP.log ("Het spel is begonnen!"); FP.world = _gameWorld; Dat is het eigenlijk wel! U zult zien dat het gedeelte "Uitvoer" van de foutopsporingsconsole nu het logboek toont. U kunt doorgaan en alle wijzigen spoor() roept onze code in voor oproepen naar FP.log ().
En dat is onze inleiding tot FlashPunk, die de belangrijkste aspecten van deze verbazingwekkende bibliotheek beslaat: entiteiten, werelden, afbeeldingen en animaties; botsing, knoppen, invoer en beweging. Ik hoop dat je deze bibliotheek net zo leuk zult vinden als ik - het maakt het werk echt gemakkelijker!
