Learnit Training

10. ActionScript

In het hoofdstuk interactiviteit heb je kunnen leren hoe je met behulp van ActionScript acties kunt koppelen aan events. In dat hoofdstuk zijn we alleen in gegaan op relatief eenvoudige script, waarin de code die bij het event hoort keurig van boven naar beneden wordt uitgevoerd. ActionScript is in feite een object georiënteerde programmeertaal, wat inhoudt dat er veel meer mogelijk is dan alleen acties in een bepaalde volgorde uitvoeren. Zo kun je je eigen functies programmeren die je kunt aanroepen vanuit je ActionScript code. Ook is het mogelijk nieuwe objecten te maken, met eigen functies en eigenschappen.

Voor mensen die al eerder met een objectgeoriënteerde programmeertaal hebben gewerkt, zullen deze begrippen misschien vertrouwd klinken. Op een paar belangrijke verschillen na (bijvoorbeeld de manier waarop een klasse wordt aangemaakt en opgebouwd), heeft ActionScript dan ook veel overeenkomsten met object-georiënteerde programmeertalen als C++ en Java.

Mochten woorden als klasse, object en functie je volkomen onbekend in de oren klinken; niet getreurd. In ActionScript kun je heel veel maken zonder dat je alles weet van de werking van objecten.

Ook in dit hoofdstuk zullen we niet al te lang stilstaan bij het concept object, in plaats daarvan behandelen we de basis van het programmeren in ActionScript. De eerste twee paragrafen bevatten basiskennis over variabelen en expressies die noodzakelijk is om te programmeren in een programmeertaal als ActionScript. De derde paragraaf zal ingaan op de concrete mogelijkheden om vanuit ActionScript het verloop van de movie of een movieclip te beïnvloeden. Paragraaf vier zal gaan over twee belangrijke acties die je in iedere programmeertaal in een bepaalde gedaante terug zult vinden: de if en de while actie.

Het venster ObjectActions

Het Actions-venster bestaat uit twee delen: aan de linkerkant van het scherm staan (in boekjes die opengevouwen kunnen worden) alle mogelijke Acties die je kunt gebruiken, in de rechterhelft verschijnt de ActionScript code die je zelf hebt gemaakt. Er zijn drie methoden om acties aan de code toe te voegen. Ten eerste kun je acties van de linkerhelft naar de rechterhelft van het venster te verslepen naar de plaats waar je de actie wilt toevoegen.

Toevoegen acties

Ten tweede is het mogelijk om uit het toevoeg-menu, dat verschijnt als je op de knop met het +-teken linksbovenin het scherm drukt, een actie te kiezen, zodat hij wordt ingevoegd direct onder de op dat moment geselecteerde regel. De derde mogelijkheid is alleen geschikt voor gevorderde gebruikers. Het is namelijk ook mogelijk om niet ActionScript de regels in te laten voegen, maar ze zelf in te typen. Het is van belang te beseffen dat dit alleen werkt als je de acties precies op de juiste manier (zonder spelfouten, hoofdlettergevoelig!, geen punt-komma's vergeten, geen haakjes-sluiten vergeten etc.) intypt.

Overschakelen op de expert mode

Als je de code zelf in wilt voeren moet je het venster op Expert-mode in plaats van Normal-mode zetten. In dit hoofdstuk zullen we alle acties invoeren via de tweede methode, met het toevoegmenu, maar met de andere twee methoden kan het natuurlijk net zo goed.

10.1 Variabelen in ActionScript

Vaak gebeurt het dat je in je code (tijdelijk) bepaalde waarden op wilt slaan om later weer te gebruiken. Als je bijvoorbeeld een rekenmachientje wilt maken in Flash, zul je moeten 'onthouden' welke waarden zijn ingevoerd en als je een spelletje programmeert wil je opslaan wat de score of tussenstand is. Ook wil je bijvoorbeeld soms 'onthouden' of een bepaalde knop al eerder ingedrukt is.

Dit onthouden doe je in een variabele. Een variabele is een stukje geheugen dat je zelf als programmeur een bepaalde naam meegeeft en waarin je een waarde kunt opslaan. De variabele die de score van het spelletje bijhoudt kun je bijvoorbeeld actueleScore noemen. In deze variabele kun je nu een waarde opslaan, je kunt er berekeningen mee uitvoeren en de waarde weer weergeven in bijvoorbeeld het score-venster van je spelletje.

Behalve numerieke waarden is het ook mogelijk om tekst op te slaan in een variabele. Een variabele die tekst bevat wordt ook wel een string genoemd. Soms hoeft een variabele die je aanmaakt maar twee verschillende waarden aan te kunnen nemen. Een variabele die onthoudt of een knop al eerder ingedrukt is geweest is een voorbeeld van zo'n variabele: of de knop is niet ingedrukt geweest of hij is het wel geweest, andere mogelijkheden zijn er niet. Een dergelijke variabele wordt een boolean genoemd. De twee waarden die een boolean aan kan nemen worden meestal aangeduid met False (onwaar) of het getal 0 en True (waar) of het getal 1.

Als je eenmaal een variabele hebt aangemaakt kun je de naam van de variabele overal waar een getal of een string moeten komen intypen. Actionscript vult dan bij het uitvoeren automatisch de waarde in die de variabele op dat moment heeft.

10.1.1 De set variable actie

Een variable toevoegen

Om een variabele aan te maken (te declareren) en er iets in op te slaan (de variabele een waarde te geven) wordt de action set variable gebruikt. Om deze actie in de code in te voegen, druk je op de knop met de plus (linksboven in het code-venster) en kies je uit het submenu Actions de actie set variable. In het vak variable dat onder in het venster verschijnt kun je nu opgeven hoe de aan te maken variabele moet gaan heten. In het vak Value kun je opgeven welke waarde moet worden opgeslagen; dus welke waarde moet worden toegekend aan de variabele.

De waarde en de naam van een variable invullen

Als je een getalswaarde wilt toekennen, moet je eerst het selectievakje expression, rechts van het vak Value aanvinken. Als het vakje expression is ingeschakeld is er nog meer mogelijk. Zo kun je ook de naam van een andere variabele invullen. Op deze manier krijgt de nieuwe variabele dezelfde waarde als die andere variabele. Ook is het mogelijk een berekening in te vullen of de naam van een functie. Meer hierover in de paragrafen Rekenen met variabelen en Expressies.

Als je wilt dat de variabele de informatie die in het value-vak is opgegeven als letterlijke tekst opslaat, moet het vakje expression leeg blijven. De variabele is nu een variabele van het type string en bevat letterlijk de tekst die in het value vak is getypt.

Om de waarde van een bestaande variabele te veranderen gebruik je opnieuw de actie set variabele en vul je de naam van de variabele exact in (dus ook dezelfde hoofdletters/kleiner letters gebruiken!). De oude waarde van de variabele wordt nu als het ware overschreven met de nieuwe waarde.

10.1.1.1 Naamgeving

Het is van belang dat je je variabele een goede, duidelijke naam mee geeft. Zorg ervoor dat de naam van de variabele zo is dat je, als je later je code weer eens bekijkt, het in één keer duidelijk is wat de functie van de variabele is. Behalve dat je ervoor moet zorgen dat de naam duidelijk is, moet hij ook aan een aantal eisen voldoen: de naam kan alleen bestaan uit letters, cijfers, het underscoreteken (_) en het dollarteken ($). Verder mag het eerste teken geen cijfer zijn en mag de naam niet al eerder gebruikt zijn en ook geen betekenis hebben binnen Actionscript (het mag dus bijvoorbeeld niet de naam van een actie zijn). Belangrijk is het ook om er bij stil te staan dat de naam van een variabele hoofdlettergevoelig is. ditIsEenVariabele is dus een andere variabele dan Ditiseenvariabele.

Overigens is het in de programmeerwereld gebruikelijk om het eerste teken een kleine letter te laten zijn, dit om de namen van variabelen te kunnen onderscheiden van namen van klassen (die verderop in dit hoofdstuk nog kort aan bod zullen komen). De notatie ditIsEenVariabele is de meest gebruikte, waarbij bij ieder nieuw woord een nieuwe hoofdletter wordt gebruikt. Soms wordt ook de underscore gebruikt als een soort spatie (dus dit_is_een_variabele). Namen van eigenschappen (waar we het later nog over zullen hebben) beginnen normaal gesproken met een underscore.

10.2 Expressies

Al vaak hebben we gezien dat je, als je een actie hebt ingevoegd of selecteert, onder in het scherm verschillende 'parameters' van de actie kunt instellen. Vaak moet je tekst of een getalswaarde opgeven.

In ActionScript is het, net als in alle programmeertalen, ook mogelijk om in plaats van een waarde een zogenaamde expressie (uitdrukking) op te geven. Een expressie is een regel die ActionScript genoeg gegevens geeft om zelf een waarde in te vullen. Dit kan op verschillende manieren. Een van de manieren is door ActionScript een formule te geven waarmee het zelf de waarde kan berekenen. Ook kun je ActionScript de waarde ergens anders vandaan laten halen, namelijk uit een andere variabele, een eigenschap van een object of uit een zogenaamde functie. Natuurlijk kun je ook dit alles combineren, je kunt een formule maken die zo ingewikkeld is als je zelf wilt. Voor strings werken expressies anders dan voor numerieke variabelen, dus je moet altijd goed in de gaten houden of je met getallen of met teksten aan het werken bent.

We zullen hier achtereenvolgens ingaan op expressies die een cijfer als resultaat hebben, expressies die een string als resultaat hebben en expressies waarvan de uitkomst een boolean is.

Een handige manier om te controleren wat de uitkomst zal zijn van een expressie is door gebruik te maken van de action trace. Deze actie is speciaal bedoeld om het programmeren makkelijker te maken en opent een speciaal scherm waarin de uitkomst van een bepaalde expressie wordt weergegeven.

De actie Trace

Om een trace-actie in te voegen druk je op het plus-knopje links bovenin het codevenster en kies je uit het submenu Actions de actie trace. Onderin het venster kun je nu, als je het selectievakje expression aanvinkt, in het vak Message een expressie intypen, waarvan de uitkomst, als je de movie uitvoert, in een speciaal berichtenvenster zal worden weergegeven.

10.2.1 Rekenen in een expressie

In een expressie kun je optellen, aftrekken, vermenigvuldigen en delen. Om te rekenen maak je gebruik van zogenaamde operatoren. Je kunt de volgende operatoren gebruiken voor berekeningen:

+ De twee waarden optellen
- De rechterwaarde van de linkerwaarde aftrekken
* De twee waarden vermenigvuldigen
/ De linkerwaarde delen door de rechterwaarde
% De restwaarde bij een deling van de linkerwaarde door de rechterwaarde

Bij een berekening worden de bewerkingen in de binnen de wiskunde gebruikelijke volgorde uitgevoerd: eerst vermenigvuldigingen en delen, dan optellen en aftrekken ('Meneer Van Dale Wacht Op Antwoord'). Om de volgorde van berekenen te beïnvloeden kun je net als in de wiskunde haakjes gebruiken.
Voor ingewikkeldere rekenkundige functies (zoals machtsverheffen), zul je de functies van het Math-object moeten gebruiken. Hierover meer in de paragraaf over ingebouwde objecten.

In je berekeningen kun je natuurlijk in plaats van getallen ook weer de namen van variabelen (die moeten natuurlijk wel een getalswaarde bevatten, het mogen geen strings zijn!) of andere expressies invullen.

Een aantal voorbeelden van berekeningen als expressies:

5 + 4 Vijf optellen bij vier (geeft dus als waarde negen)
9 - 4 * 2 Vier vermenigvuldigen met twee (vermenigvuldigen altijd eerst: is acht) en dit aftrekken van negen (geeft dus als waarde één)
(9 - 4) * 2 Negen van vier aftrekken (eerst haakjes: is vijf) en dit vermenigvuldigen met twee (geeft dus als waarde tien)
10 / 4 Tien delen door vier (geeft dus als waarde 2.5)
10 % 4 Restwaarde als je tien door vier deelt. Acht is het getal dat het dichtst onder de tien zit dat deelbaar is door vier. De restwaarde bij een deling door vier is dus tien min acht, is twee.
appel + peer + 5 Tel de waarde van de variabele appel op bij de waarde van variabele peer en tel hier nog eens 5 bij op

10.2.2 Werken met Strings

Ook voor strings kun je expressies maken. De bewerkingen werken anders dan bij cijfers. Met strings valt niet te rekenen, maar er zijn wel andere mogelijkheden. Zo is het mogelijk om meerdere strings achter elkaar te 'plakken' en zo samen te voegen tot één string. Ook is het mogelijk binnen een string bepaalde woorden te zoeken, of bijvoorbeeld alleen een bepaald aantal letters vanaf het begin van de string weer in een nieuwe string te zetten.

Behalve dat je binnen een string-expressie een string-variabele kunt gebruiken, is het ook mogelijk de string zelf in de expressie te zetten. Dus niet de naam van een eerder ingevoerde variabele opgeven, maar direct een tekst in de expressie verwerken. Om een tekst op te nemen in een expressie kun je deze tekst tussen (dubbele) aanhalingstekens zetten. Wil je dus de tekst 'Hallo' gebruiken in een expressie, dan doe je dat door in die expressie "Hallo" te zetten. Wil je in plaats van het getal 5 de tekst 5 gebruiken (de 5 wordt dan dus alleen als teken beschouwd, net als iedere letter of ieder leesteken), dan gebruik je in plaats van 5 dus "5". Zie ook de voorbeelden aan het einde van deze paragraaf om te zien hoe je precies met aanhalingstekens werkt.

Voor strings is slechts één operator beschikbaar, namelijk:

+ De twee strings achter elkaar plakken

Let goed op: de + operator is wordt ook gebruikt voor expressies met numerieke waarden. Op het moment dat één van de twee waarden (links of rechts van het + teken) geen numerieke waarde, maar een string is, worden beide waarden beschouwd als een string en worden de twee aan elkaar geplakt. Als je dus de tekst 'Hallo' optelt bij het getal 2, is de uitkomst een nieuwe string, namelijk: 'Hallo 2'.

Er is nog veel meer mogelijk dan alleen het aan elkaar plakken van strings. Het is namelijk mogelijk om methoden van het string-object los te laten op een string. Hiervoor wordt de string tijdelijk omgezet in een string-object. Het voert te ver om hier uit te leggen wat dit exact inhoudt; het gaat erom dat je weet hoe je deze methoden kunt gebruiken. De belangrijkste methoden die je op een string kunt laten werken zijn:

String.charAt(index) Geeft de letter die in de string staat op de plaats van het getal dat is gegeven bij index. De eerste letter heeft index 0, de tweede letter index 2 etc.
String.indexOf (value, start) Zoekt waar voor het eerst in de string de tekst die op de plaats van value opgegeven wordt staat. Op de plaats van start geef je de indexwaarde op vanaf waar gezocht moet worden in de string. Deze methode krijgt de waarde van de index waar de tekst gevonden wordt en als de tekst niet voorkomt in de string geeft hij de waarde 0.
String.lastIndexOf(substring, start) Werkt hetzelfde als index of, met dat verschil dat deze methode juist het indexnummer geeft van de laatste keer dat de tekst voorkomt in de string.
String.length Geeft het aantal tekens dat de string bevat
String.substring(from, to) Geeft een bepaald gedeelte van de string. Het gedeelte begint bij het teken dat ligt op de plaats van de index die is opgegeven bij from en eindigt bij het teken dat staat op de plaats die bij to is opgegeven. Als je als indexwaarde bij start of end een negatief nummer opgeeft, wordt de index afgeteld vanaf het einde van de string.
substring(string, index, count) Werkt ongeveer hetzelfde als String.substring, alleen bestaat het gedeelte uit het aantal tekens dat bij count is opgegeven, te beginnen bij index.
String.toLowerCase() toLowerCase maakt van alle letters in de string kleine letters.
String.toUpperCase() toUpperCase maakt van alle letters in de string hoofdletters.

De methoden in de bovenstaande tabel nemen de waarden van de uitkomst aan, je kunt ze op precies dezelfde manier als variabelen in een expressie verwerken. In alle bovenstaande methoden moet ergens een string worden ingevuld. In de meeste gevallen doe je dit voor de punt (.), maar soms moet er achter de naam van de methode (ook) tussen haakjes string(s) of numerieke waarden worden gegeven, als het er meerdere zijn worden ze door komma's gescheiden. Deze waarden worden de parameters of argumenten van de methodes genoemd. Op de plaatsen waar een string moet worden ingevuld mag dit tekst tussen aanhalingstekens zijn, maar ook de naam van een string-variabele en ook een expressie die als uitkomst een string heeft. Natuurlijk mag je ook weer een methode invullen die als resultaat een string geeft.

Hierna volgt een aantal voorbeelden van expressies die een string opleveren:

Expressie(Mogelijke) UitkomstToelichting
5 + "4""54"In deze optelling komt een string voor ("4", door de aanhalingstekens), dus wordt ook 5 beschouwd als tekst en de twee tekens worden achter elkaar geplakt.
"Hallo " + naam"Hallo Piet"Achter "Hallo " wordt de waarde van de variabele naam geplakt.
(2 + 1) + ("2" + 1)"321"(2+1) zijn twee numerieke waarden en die worden dus normaal opgeteld (wordt dus 3). "2" + 1 bevat een string en wordt dus een nieuwe string waarbij "2" en "1" achter elkaar worden geplakt ("21"). Tot slot wordt "21" aan "3" geplakt ("21" is een string, dus wordt 3 ook omgezet in een string).
"Flash".charAt(2)"a"Geeft het derde teken van de string "Flash" (charAt(0) zou het eerste teken, de F, geven)
"Hallo".toLowerCase()"hallo"Maakt van alle hoofdletters (in dit geval alleen de H) kleine letters. Dit is vooral handig als je niet hoofdlettergevoelig wilt zoeken in een string. Als je deze methode loslaat zowel op de te zoeken string als op de string waarin gezocht wordt, wordt er dus niet hoofdlettergevoelig gezocht.

10.2.2.1 Een voorbeeld

In de volgende voorbeeldexpressie worden meerdere soorten methoden gecombineerd:

substring(Tekst, (Tekst.indexOf( "Flash", 0 ) + 1), "Flash".length)

Deze lange expressie (die gewoon als een lange regel moet worden ingevoerd in een vak waar een expressie mag worden ingevoerd), zoekt naar de eerste plaats waar het woord Flash in de stringvariabele Tekst voor komt. Als hij dit woord heeft gevonden wordt het stukje tekst genomen dat begint op de plek waar het woord Flash is gevonden en zoveel tekens doorloopt als het woord Flash bevat. Het komt er op neer dat precies het woord Flash er uitgelicht wordt. Als je nu eerst met de set variable actie een tekst invoert voor de variabele Tekst (bijvoorbeeld "Deze tekst bevat het woord Flash" ­ denk aan de hoofdletter waarmee het woord Flash begint, anders wordt het niet gevonden) en vervolgens een Trace-actie toevoegt, die je als expressie in het vak message de bovenstaande expressie meegeeft, dan zal inderdaad het woord Flash in een apart scherm verschijnen. Je hebt verder niks aan deze expressie (je had immers ook meteen het woord "Flash" kunnen typen), maar hij illustreert wel goed de werking van string-expressies.

Hoe werkt nu deze expressie? De methode substring kent drie parameters, die met z'n drieën door komma's gescheiden tussen haakjes staan. De eerste parameter is de string waaruit het stukje tekst moet worden gepakt. In dit geval is dat de string die in de variabele Tekst is gezet. De tweede parameter geeft aan vanaf het hoeveelste teken van de string het stukje begint. In deze expressie is dat de uitkomst van de expressie Tekst.indexOf( "Flash", 0 ) + 1. Deze expressie zoekt naar het woord Flash in de string Tekst vanaf het eerste teken (dat wordt aangegeven door de 0. Omdat indexof het eerste teken telt als 0, levert deze methode een waarde op die eigenlijk 1 te laag is, daarom wordt er met de opdracht + 1 nog één bij opgeteld. De uitkomst is dus nu de positie van het eerste teken van de eerste keer dat het woord Flash voorkomt in de string Tekst. De derde parameter geeft aan hoelang het te pakken stukje tekst moet zijn. De expressie "Flash".length geeft de lengte van de string "Flash" (dus 5). Op deze manier wordt dus precies het woord Flash uit de string Tekst gelicht.

10.2.3 Booleans en Boolean expressies

Een boolean variabele aanmaken

Een boolean is in feite een variabele die slechts twee waarden aan kan nemen: true/waar (1) of false/onwaar (0). Een boolean variabele maak je aan met de set variable actie, waarbij je in het vak value true of false invult met het vakje expression ingeschakeld.

Er is ook nog een speciale manier om berekeningen te maken die als uitkomst een boolean hebben. Dat kan door een zogenaamde bewering te schrijven. Als de bewering waar is, is de uitkomst true (1) en als de bewering onwaar is, is de uitkomst false (0). De meeste beweringen hebben te maken met vergelijkingen. Voor deze vergelijkingen bestaan speciale operatoren. Er zijn verschillende soorten beweringen met een vergelijking mogelijk:

== Gelijkheid de twee waarden (of strings ­ hoofdlettergevoelig!) zijn gelijk aan elkaar
!= Ongelijkheid de twee waarden (of strings ­ hoofdlettergevoelig!) zijn ongelijk aan elkaar
< Kleiner dan de linkerwaarde is kleiner dan de rechterwaarde
<= Kleiner dan of gelijk aan de linkerwaarde is kleiner dan of gelijk aan de rechterwaarde
> Groter dan de linkerwaarde is groter dan de rechterwaarde
>= Groter dan of gelijk aan de linkerwaarde is groter dan of gelijk aan de rechterwaarde

Let er op dat je, als je een vergelijking maakt, een dubbel = -teken gebruikt (==), een enkele = wordt in de ActionScript-code gebruikt voor de set-variable actie.

Naast de operatoren die beweringen doen aan de hand van vergelijkingen, zijn er ook nog twee zogenaamde logische operatoren:

&& En beide waarden (beweringen) zijn waar
|| Of één van de twee waarden (beweringen) is waar

Deze twee operatoren vergelijken links en rechts een boolean waarde. Als boolean waarde kan een boolean variabele gebruikt worden, maar ook is het mogelijk een expressie te gebruiken die als uitkomst een boolean heeft. Zo is bijvoorbeeld de volgende expressie waar wanneer de variabele x groter dan of gelijk aan 8 is of wanneer x kleiner is dan 2: (x < 2)||(x >= 8).

Het grote belang van boolean expressies zal vooral duidelijk worden als we gaan werken met de if-action en de while-action.

10.3 De movie beïnvloeden vanuit ActionScript

Uiteindelijk programmeer je natuurlijk in ActionScript om je movie te kunnen laten reageren op dingen die de gebruiker doet. Het gaat er dus uiteindelijk om ervoor te zorgen dat je bijvoorbeeld het gedrag van movieclips kunt veranderen. Er zijn verschillende manieren om de ActionScript code invloed uit te laten oefenen op de movie. Ten eerste hebben movieclips eigenschappen. Deze eigenschappen werken eigenlijk net als variabelen, alleen zijn ze al aangemaakt en wijzig je door de waarde ervan te wijzigen een bepaalde eigenschap van de movie of movieclip.

Naast eigenschappen hebben movieclips ook methoden. Methoden zijn eigenlijk een soort opdrachten die je aan een movieclip kunt geven. Zo kun je een movieclip de opdracht geven te beginnen met spelen.

Dingen die methoden of eigenschappen hebben worden in de programmeerwereld objecten genoemd. Een movieclip is dus een object. ActionScript bevat, naast movieclips, nog meer zogenaamde ingebouwde objecten (het is ook mogelijk om zelf nieuwe objecten aan te maken, maar dat voert te ver om hier te bespreken). Deze objecten bevatten meestal een aantal methoden of eigenschappen, die je goed in je code kunt gebruiken. Zo bevat het object Math verschillende methoden om wiskundige berekeningen uit te voeren, bevatten de objecten Key en Mouse methoden die respectievelijk te maken hebben met de toetsen op het toetsenbord en het gedrag van de muisaanwijzer (zichtbaar of onzichtbaar).

10.3.1 Movieclips benaderen

Als je een eigenschap van een bepaalde movieclip wilt veranderen, of een bepaalde methode wilt aanroepen, moet zul je ActionScript duidelijk moeten maken om welke movieclip het gaat. Hiervoor is het om deze reden van belang dat je instanties van MovieClips namen meegeeft. Dit kan in het instantie-panel van een MovieClip.

Als je een movieclip een naam hebt gegeven kun je een methode behorende bij de movieclip aanroepen.

Een methode van een movieclip voeg je in de code in door in het plus-menu (linksbovenin het scherm) te gaan naar Objects>MovieClips en in dit submenu een methode uit te kiezen. Als je bijvoorbeeld de methode stop kiest, verschijnt er onderin het beeld slechts één parameter die te wijzigen is, namelijk Expression, met de al vooringevulde tekst .stop(). Als je hier verder niks aan verandert, doet deze actie helemaal niks en zal er bij het uitvoeren van je code een foutmelding verschijnen. Voor de punt moet namelijk normaal gesproken eerst nog de naam van de MovieClip worden ingevuld die je wilt stoppen, dus bijvoorbeeld: vliegtuig.stop()

Als je de actie uitvoert vanuit de code behorende bij een button of een frame, dan moet de genoemde movieclip voorkomen in dezelfde movieclip als waar de button of het frame in staat. Als het frame of de button bij de hoofd-movie hoort, moet de aangeroepen movieclip ook onderdeel zijn van de hoofdmovie (en dus niet in een andere movieclip zitten).

Als je de methode aanroept vanuit een movieclip-event, dan geldt dat de naam van de movieclip die je opgeeft moet voorkomen als movieclip in de movieclip waarvan het event is.

Het kan ook zijn dat je naar aanleiding van een button-event of het bereiken van een frame een methode wilt uitvoeren van de movieclip (of de hoofd-movie) waarin zich de button of het frame bevindt zelf. In dat geval kun je de punt voor de methode verwijderen (dus alleen stop()). Als je de punt verwijdert voor een methode die je uitvoert binnen de code van een movie-clip event, dan roep je de methode aan voor de movieclip waar het event bij hoort.

Als je toch een movieclip in een movieclip wilt benaderen, kun je dat doen door voor de naam van de movieclip die je wilt benaderen weer een punt en daarvoor de naam van de movieclip waarin de te benaderen movieclip staat in te vullen. Dus bijvoorbeeld:
vliegtuig.propeller.stop() als propeller een movieclip is die weer in de movieclip vliegtuig voorkomt.

Stel nu dat de movieclip vliegtuig (die in de hoofdmovie staat) naast propeller nog een tweede movieclip bevat, namelijk motor. Als je de motor stil zou willen kunnen zetten met behulp van een button in de hoofdmovie, dan zou je dat doen door die button de code vliegtuig.motor.stop() mee te geven. Het zou echter ook kunnen dat je de motor wilt kunnen stoppen zodra er bijvoorbeeld in de movieclip propeller een bepaald frame bereikt is. Dit moet je doen vanuit de code die hoort bij het frame in propeller, maar hoe benader je vanuit hier een methode van de movieclip motor? ActionScript biedt hiervoor twee oplossingen; namelijk met behulp van het codewoord '_root' en met behulp van het codewoord '_parent'.

'_root' verwijst altijd naar de hoofdmovie en achter root kun je dan ook weer alle movieclips invullen die in de hoofdmovie staan. Dit betekent dat, waar de code ook staat (en in hoeveel movieclips in movieclips), je altijd de opdracht kunt geven '_root.vliegtuig.motor.stop()'. Deze opdracht kun je dus toevoegen aan de code van een frame van de movieclip propeller.

Nog gemakkelijker is het om te werken met behulp van het codewoord '_parent'. '_parent' verwijst namelijk naar de movieclip waarin de movieclip ligt van waaruit je '_parent' aanroept. Om vanuit de code van een frame van propeller de motor te stoppen, zou je ook kunnen typen: '_parent.motor.stop()'. Hier verwijst '_parent' namelijk naar de movieclip vliegtuig. Overigens is het ook mogelijk meerdere keren '_parent' achter elkaar te zetten, om zo naar nog 'hoger gelegen' movieclips te verwijzen. Zo doet '_parent._parent.stop()' vanuit propeller de hoofd-movie stoppen (de hoofd-movie is namelijk de movie(clip) waarin de movieclip (vliegtuig) ligt waarin de movieclip propeller ligt).

Voor het benaderen van eigenschappen van movieclips gelden dezelfde regels als voor het benaderen van methoden. Ook bij eigenschappen moet je voor de punt de naam van de movieclip opgeven waarvoor de eigenschap geldt in de zogenaamde punt-notatie (dot syntax).

10.3.2 Eigenschappen

Movieclips bevatten verschillende eigenschappen. Eigenschappen zijn in feite vooraf aangemaakte variabelen die bepaalde instellingen van de movieclip bevatten.

10.3.2.1 Eigenschappen wijzigen

Er zijn twee manieren om eigenschappen van een movieclip te veranderen.
De eerste is met behulp van de setProperty actie. Om deze in te voegen kies je uit het plus-menu in het submenu Actions de actie setProperty. Onder in het venster kun je nu drie verschillende parameters instellen. Ten eerste is dat de afrollijst Property, waar je op kunt geven welke eigenschap je wilt veranderen. De belangrijkste eigenschappen die te veranderen zijn zijn:
_alpha alpha transparency van een movieclip
_focusrect Boolean: als true, dan wordt er een gele rechthoek gezet om de actieve knop of het actieve tekstvak als de gebruiker op de tab-toets drukt, als false dan geen gele rechthoek.
_height De hoogte (in pixels) van de movieclip of movie
_name De naam van de movieclip
_quality String die de kwaliteit aangeeft waarmee movies worden afgespeeld:
  • 'LOW': Lage kwaliteit
  • 'MEDIUM': Middelmatige kwaliteit
  • 'HIGH' Hoge kwaliteit (standaard instelling)
  • 'BEST' Beste kwaliteit

_rotation Mate (aantal graden) van rotatie van de movieclip
_soundbuftime Aantal seconden dat er een buffer opgeslagen wordt voordat een geluidsfragment begint met spelen
_visible Boolean: als true dan is de movieclip zichtbaar, als false dan is de movieclip niet zichtbaar
_width De breedte (in pixels) van een movieclip
_x De x-coördinaat van de movieclip (in pixels) in relatie tot de grenzen van de movieclip waarin de movieclip staat
_y De y-coördinaat van de movieclip (in pixels) in relatie tot de grenzen van de movieclip waarin de movieclip staat
Vervolgens moet je in het vak target aangeven van welke movieclip de eigenschap is. Dit doe je weer met behulp van de punt-notatie. Dus hier kun je bijvoorbeeld _root.vliegtuig invullen. Bij value vul je de waarde in die de eigenschap moet krijgen. Denk er om dat je, tenzij je _quality of _name instelt (dat zijn strings), je het vakje expression aanvinkt.
Zoals al eerder gezegd werken eigenschappen eigenlijk precies als variabelen. De tweede manier om een eigenschap te wijzigen is dan ook met behulp van de set Variable actie. Het enige wat je anders moet doen dan wanneer je een variabele wijzigt is dat je als naam voor de variabele nu de naam van de eigenschap, weer in puntnotatie, moet opgeven, dus bijvoorbeeld '_parent.vliegtuig._x'. Bij value vul je de waarde in die de eigenschap moet krijgen.

10.3.2.2 Eigenschappen lezen

Behalve ze wijzigen kun je de waarden van eigenschappen ook lezen. Ook weer net als variabelen zijn ze zo te gebruiken in expressies, of als expressie op zich.

Behalve de eerder behandelde eigenschappen, hebben movieclips ook nog een aantal alleen-lezen eigenschappen, die dus niet te wijzigen zijn maar wel te gebruiken in expressies. De belangrijkste alleen-lezen eigenschappen zijn:

_currentframe Geeft het nummer van het frame waar de movieclip zich op dit moment met afspelen bevindt.
_framesloaded Het aantal frames dat tot nu toe is geladen van een streaming movie(clip)
_totalframes Het aantal frames dat de movie(clip) bevat
_url Het internet-adres (URL) van het swf-bestand vanwaaruit de movieclip gedownload is
_xmouse De x-coördinaat van de muis-positie
_ymouse De y-coördinaat van de muis-positie

Door eigenschappen in expressies te verwerken kun je bijvoorbeeld een movieclip over het scherm laten schuiven door bijvoorbeeld steeds de eigenschap '_x' in te stellen op '_x + 1'. Door deze toewijzing van 'movieclip._x + 1' aan 'movieclip._x' aan een knop te verbinden maak je een knop om de movieclip een pixel naar rechts te verschuiven.

10.3.3 Methoden

Methoden zijn opdrachten die je aan een movieclip geeft. Methoden voeg je in door in het plus-menu naar het submenu Objects>MovieClips te gaan en daaruit een methode te kiezen. We hebben al eerder behandeld hoe je op moet geven op welke MovieClip de methode van toepassing is. In deze paragraaf zullen we de verschillende methoden behandelen. Soms hebben methoden bepaalde parameters, waarmee je instellingen voor de door de movieclip uit te voeren opdracht kunt meegeven. Deze parameters staan altijd tussen haakjes. In de volgende tabel staan de belangrijkste movieclip-methoden. Parameters die ingevuld moeten worden staan cursief geschreven.

gotoAndPlay(frame) Laat de movieclip naar het bij frame opgegeven frame gaan en verder spelen
gotoAndStop(frame) Laat de movieclip naar het bij frame opgegeven frame gaan en stoppen
nextFrame() Laat de movieclip naar het volgende frame gaan
play() Laat de movieclip beginnen met spelen
prevFrame() Laat de movieclip naar het vorige frame gaan
startDrag() Maakt de movieclip met de muis versleepbaar.
stop() Doet de movieclip stoppen met spelen
stopDrag() Maakt de movieclip niet meer met de muis versleepbaar

Er zijn nog meer methoden die onder andere betrekking hebben op het laden van nieuwe movieclips, het dupliceren van movieclips en de positie van movieclips. Als je meer informatie wilt over deze methode kun je kijken in de bij Flash geleverde ActionScript Dictionary. Kies hiervoor Help>ActionScript Dictionary.

10.3.4 Ingebouwde klassen en objecten

Een object hoeft niet per se een movieclip te zijn, er zijn meer soorten objecten. En het is niet alleen mogelijk nieuwe objecten van het type movieclip aan te maken, maar er zijn meerdere soorten objecten die je aan kunt maken (zo is het bijvoorbeeld mogelijk een object van het type Array of van het type String of van het type Sound aan te maken). Het is zelfs mogelijk nieuwe ontwerpen voor nieuwe typen objecten te maken (zogenaamde klassen). In veel zogenaamde object-geörrienteerde programmeertalen bestaat het programmeren vooral uit het aanmaken van nieuwe objecten en nieuwe klassen. In ActionScript is (gelukkig) een heleboel nodig zonder veel kennis van deze mogelijkheden. We zullen hier dan verder ook niet ingaan op de mogelijheden om nieuwe objecten, laat staan nieuwe klassen, aan te maken. Wel is het handig om te weten hoe je de ingebouwde klassen (dus typen objecten) van Flash kunt gebruiken. Vooral de Math-klasse kan erg praktisch zijn. Objecten van het type Math bevatten een hele serie methoden die een bepaalde berekening uit kunnen voeren.

Als je methoden wilt gebruiken die in bijvoorbeeld de Math klasse worden omschreven is het mogelijk om eerst een nieuw object van het type Math aan te maken en vervolgens de desbetreffende methode in het nieuw aangemaakte object aan te roepen. Voor de methoden van Math-objecten geld echter dat ze altijd precies hetzelfde doen, ongeacht van welk object ze zijn. Omdat het voor zulke methoden een beetje omslachtig is om eerst een object aan te maken, kun je ze ook direct uit het ontwerp (dus de klasse) aanroepen.

De methoden van de Math-klasse leveren allemaal waarden op. Dat betekent dus dat je ze binnen een expressie kunt (moet) gebruiken, wil je iets met de uitkomst doen. De belangrijkste methoden van de klasse Math zijn (met cursief de in te vullen parameters)

abs(x) Berekent de absolute waarde van x
acos(x) Berekent een arc cosinus van x
asin(x) Berekent een arc sinus van x
atan(x) Berekent een arc tangens van x
atan2(y, x) Berekent de hoek van de x-as tot het punt (y, x)
ceil(x) Rondt het getal naar boven af
cos(x) Berekent de cosinus van hoek x
E Geeft het wiskundige getal e (2,71828...)
exp(x) Geeft het getal e tot de macht x
floor(x) Rondt het getal naar beneden af
log(x) Berekent het natuurlijk logaritme van x
max(x, y) Geeft het hoogste cijfer van x en y
min(x, y) Geeft het laagste cijfer van x en y
PI Geeft het wiskundige getal pi (3,14159...)
pow(x, y) Berekent x tot de macht y
random Geeft een willekeurig nummer tussen 0.0 en 1.0
round(x) Rondt x af naar het dichtstbijzijnde gehele getal
sin(x) Berekent de sinus van hoek x
sqrt(x) Berekent de wortel van x
tan(x) Berekent de tangens van hoek x

Al deze methoden zijn te gebruiken binnen expressies. Als parameters kan natuurlijk behalve een getalswaarde ook weer een expressie of een variabele worden opgegeven. Je kunt ze in je expressie invoegen vanuit het plus-menu door in het submenu Objects>Math een methode uit te kiezen. Ook kun je ze zelf in je expressie typen. Om aan te geven dat het gaat om een methode van de Math-klasse, typ je voor de naam van de methode dan eerst 'Math.'. Wil je dus bijvoorbeeld de waarde van pi in je expressie gebruiken, dan typ je 'Math.PI'. Wil je variabele x tot de macht 3 gebruiken, dan typ je 'Math.pow(x, 3)'.

Zoals je in het submenu Objects kunt zien bevat flash nog veel meer voorgeprogrammeerde klassen. Het voert te ver om ze hier allemaal te behandelen. Als je meer informatie wilt over deze klassen en hun bijbehorende type objecten, kun je kijken in de ActionScript Dictionary (Help>ActionScript Dictionary).

10.4 if en while

Tot nu toe hebben we steeds gekeken naar ActionScript code, waarvan de acties van boven naar beneden, regel voor regel, worden uitgevoerd. Het is echter ook mogelijk om de manier waarop ActionScript door de code loopt te beïnvloeden. Met de if-actie is het bijvoorbeeld mogelijk om een bepaald stukje code alleen te doorlopen als er aan een bepaalde voorwaarde voldaan is. De while-actie geeft de mogelijkheid om een stukje code net zo vaak te doorlopen tot niet meer aan een vooraf opgegeven voorwaarde is voldaan. Met while wordt dus een aantal keer na elkaar bepaalde code uitgevoerd. Men noemt dit ook wel een 'lus' (in het Nederlands) of een 'loop' (in het Engels).

10.4.1 De if actie: code alleen onder bepaalde voorwaarden uitvoeren

Eén van de meest praktische functies van programmeertalen is de mogelijkheid om code alleen onder een bepaalde voorwaarde uit te voeren. Dit doe je in ActionScript (zoals overigens in de meeste programmeertalen) met behulp van de if-action. De voorwaarde waaraan voldaan moet worden geef je op met behulp van een boolean expressie: is de expressie waar (true), dan wordt de code uitgevoerd. Is de expressie onwaar (false), dan wordt de code niet uitgevoerd of wordt er een alternatief stukje code uitgevoerd.

De If actie toevoegen

Een if actie voeg je in je code in, door op de plusknop linksboven in het scherm te drukken en in het submenu actions te kiezen voor if. In het codevenster verschijnen nu twee nieuwe regels: een regel met het codewoord if en daarachter tussen haakjes de voorwaarde, gevolgd door een openende accolade ({). De regel daaronder bevat alleen een sluitende accolade (}). De regels code die je tussen deze twee regels (beter gezegd: tussen de accolades) invoegt, wordt alleen uitgevoerd als aan de in de eerste if-regel opgegeven voorwaarde is voldaan.

Als in het code-venster de regel met de if-actie is geselecteerd, verschijnt onderaan een invulvak dat 'condition' heet. Hier moet je een boolean expressie opgeven, die dient als voorwaarde voor de if-actie.

De boolean expressie zal in veel gevallen slechts bestaan uit een vergelijking tussen een variabele en een vaste waarde, bijvoorbeeld:

    if (leeftijd >= 18) {	    meerderjarig = true;
    }

Dit is de code die verschijnt als je tussen de twee if-regels (tussen de accolades) een set variable actie invoegt die de (boolean) variabele meerderjarig op true (waar) stelt. De bewering leeftijd >= 18 is waar als de variabele leeftijd groter of gelijk is aan 18. Dit is de bewering die in het condition-vak van de if-actie is ingevoerd. Als leeftijd groter of gelijk is aan 18 wordt dus de variabele meerderjarig op waar ingesteld.

Vaak komt het voor dat je wilt dat er als de bewering niet waar is een ander stukje code wordt uitgevoerd (dat dus niet wordt uitgevoerd als de bewering waar is). Voor deze situatie heeft ActionScript de else-actie. Om deze actie te gebruiken maak je eerst een normale if-actie aan en je zet, zoals gebruikelijk, de acties die je wilt uitvoeren als de bewering waar is tussen de if-regel en de regel met de afsluitende accolade. Vervolgens voeg je direct na de laatste van deze acties (dus direct voor de afsluitende accolade) een else-actie in (menu met de plus>Actions>else). Achter deze else-actie kun je nu de acties invoegen die worden uitgevoerd als de bewering niet waar was. De code die met zo'n else-actie in het code-venster zal verschijnen ziet er ongeveer als volgt uit:

    if (bewering) { 	   >> acties uitgevoerd als bewering waar is
    } else { 	   >> acties uitgevoerd als bewering onwaar is
    }

Let er bij het invoeren van de acties die uitgevoerd moeten worden als de bewering onwaar is op dat je ze tussen de else-actie en de regel met de sluitende accolade invoegt.
Nadat de if-actie is afgehandeld (en dus ook - eventueel - het juiste rijtje acties binnen de if-actie is uitgevoerd), gaat ActionScript verder met de code die begint na de regel met de afsluitende accolade. Vanaf deze afsluitende accolade wordt de code dus weer gewoon altijd uitgevoerd.

10.4.2 De while actie: het bouwen van een loop

Met behulp van de while actie is het mogelijk om een stukje code meerdere keren achtereen te doorlopen. In feite lijkt de werking van de while actie erg op die van de if actie, met dat verschil dat de if-actie de code slechts eenmaal uitvoert en de while-actie net zo lang de actie blijft herhalen tot niet meer aan de vooraf opgegeven voorwaarden is voldaan. Dit wordt een lus of in het Engels een loop genoemd.

Meestal wil je dat de code die wordt herhaald zo geschreven is dat de bewering die is opgegeven bij de while-actie op een gegeven moment waar wordt, anders komt het programma nooit uit de lus en wordt de code tot in het oneindige herhaalt (een zongenaamde oneindige lus of infinite loop). De enige manier om hier voor te zorgen is door in de bewering in de while-actie een variabele op te nemen die door de herhaalde code gewijzigd wordt.

Vaak wil je dat een stukje code een van tevoren bepaald aantal keer herhaalt wordt. In dat soort gevallen maak je een aparte tellervariabele (counter) aan die bijhoudt hoe vaak de code al doorlopen is. Als je bijvoorbeeld een code tien keer wilt uitvoeren, maak je eerst een variabele aan met de set variable actie en geeft hem de waarde 0 (de lus is per slot van rekening nog maar 0 keer doorlopen). Geef deze variabele een duidelijke naam, bijvoorbeeld aantalKeerDoorlopen of korter: teller. Denk er aan dat het hier om de getalswaarde 0 gaat en niet om de tekst '0'. Bij het invoeren van de waarde 0 in het value vak van de set-variable actie moet dus het vakje Expression aangevinkt zijn.

Vervolgens voeg je een while actie in (plus-menu>Actions>while), waarbij je als voorwaarde (in het vak condition) opgeeft dat de waarde van de zojuist aangemaakte variabele kleiner is dan, in dit geval, 10. Dus bijvoorbeeld: teller < 10.

Tussen de twee regels van de while actie (tussen de accolades dus), kun je nu de code invoegen die je wilt herhalen. De truck is dat je als laatste regel, dus direct onder de laatste actie van de code en direct boven de sluitende accolade, een actie invoegt die 1 optelt bij de waarde van de tellervariabele. Op deze manier wordt de tellervariabele iedere keer dat de code doorlopen is opgehoogd met 1 en hij houdt zo precies bij hoe vaak hij dit gedaan heeft. Deze actie maak je met behulp van de set variable actie. Als variabelenaam geef je de naam van de tellervariabele (bijv. teller) en bij value geef als expressie de tellervariabele plus één (bijv teller + 1). Op deze manier zeg je dat de nieuwe waarde van teller gelijk is aan de oude waarde van teller plus één.

In de herhaalde code (dus de code die tussen de twee accolades staat), kun je nu natuurlijk ook weer gebruik maken van de waarde van de teller, om de code bijvoorbeeld steeds net iets anders te laten te doen. Een gemakkelijke manier om hier een beetje mee te experimenteren is met behulp van de trace actie die tekst in een speciaal venstertje laat verschijnen. De volgende voorbeeldcode is de code (die alleen een trace-actie bevat) die ontstaat als je een loop maakt die vier keer doorlopen wordt. De expressie waarvan trace hier de uitkomst (het gedeelte dat achter het woordje trace tussen haakjes staat) geeft bevat onder andere de waarde van de teller plus één. De teller geeft aan hoe vaak de code al doorlopen is en als je daar één bij optelt weet je voor de hoeveelste keer het nu aan het gebeuren is. Na de accoladesluitend in de code staat nog een trace-actie. Deze actie wordt uitgevoerd als de while actie voltooid is (in dit geval na vier keer doorlopen) en geeft aan op wel getal de teller is geëindigd (dus hoe vaak de while actie doorlopen is).

    teller = 0;
    while (teller < 4) {        trace ("Dit is de " + (teller + 1) + "e loop.");
        teller = teller + 1;
    }
    trace ("Na " + teller + " keer zijn we klaar.");

Als je deze hele code uitvoert, krijg je het volgende resultaat:

Dit is de 1e loop.
Dit is de 2e loop.
Dit is de 3e loop.
Dit is de 4e loop.
Na 4 keer zijn we klaar.