MACROMEDIA FLASH SCRIPT KALBOS PANAUDOJIMAS ALGORITMAVIMO ĮGŪDŽIŲ UGDYMUI – baigiamasis darbas

ĮVADAS

Algoritmavimo bei programavimo mokykloje pradedama mokyti 9-10 klasėje. Vyresnėse klasėse moksleiviai gali pasirinkti programavimą ir mokytis toliau. Programuojama daugiausiai su Turbo Paskalio kalba. Vyresnėse klasėse galima mokyti objektinio programavimo. Jis yra vaizdingesnis ir mokiniai mieliau mokosi.
Pagrindinis informatikos mokymo tikslas bendrojo lavinimo mokykloje – informacinės moksleivių kultūros ugdymas. Įgyvendinant šį tikslą siekiama moksleiviams perteikti fundamentalių informatikos žinių ir sąvokų sistemą, paskatinti juos domėtis technologinėmis naujovėmis, ieškoti ryšių su bendrąja žmonijos kultūra, ugdyti įgūdžius naudotis kompiuteriais bei kitomis informacijos technologijos priemonėmis, lavinti loginį, operacinį, algoritminį mąstymą, gebėjimą planuoti sudėtingesnių uždavinių sprendimų eigą, aprašyti ją algoritmais.
Programavimas arba algoritmavimas yra viena iš svarbiausių informatikos dalių, o uždavinio sprendimo „algoritmizavimas“ yra pagrindinė informatikos paskirtis, kurios sampratą turi įdiegti bendrojo lavinimo mokykla. Mokymas programuoti vysto loginį mąstymą ir keičiasi mokinių mokymosi būdas. Kasdienė procedūrų naudojimo ir programavimo patirtis tampa jiems pagalbos šaltiniu mokantis mokykloje. Programavimas formuoja sugebėjimą išskirti svarbiausius užduoties, problemos sprendimo etapus: analizę – užduoties išskaidymo į atskiras dalis; plano sudarymą – kaip kiekvienos dalies sprendimo; sintezę – atskirų dalių apjungimo. Išmokti programuoti kokia nors programavimo kalba – suprasti jos semantiką ir sintaksę, o tai padeda formuoti moksleivių kalbos stilių. Programavimas skatina eksperimentuoti, formuluoti ir tikrinti hipotezes.
Su kokia programavimo kalba tikslingiausia supažindinti moksleivius? Konkreti programavimo kalba – tai tik priemonė realizuoti tikslus: mokyti programuoti, sudaryti kūrybos ir atradimų aplinką ir t.t. Ir mokytojo pasirinkimas turi būti pagrįstas pirmiausia jo tikėjimu tuo, ko moko. Tik tada jis ir jo mokiniai pasieks geriausių rezultatų. Svarbiausia visiems suvokti, kad mokymas turi būti nukreiptas ne į taisyklių išmokimą, o į mąstymo proceso formavimą.
Bendrojo lavinimo mokykloje dvyliktoje klasėje įvestas informatikos kursas „Programavimas“:
1.    Programavimo kalbos ir transliatoriai.
2.    Pagrindiniai programos struktūros elementai.
3.    Pagrindiniai duomenų tipai.
4.    Pagrindinės valdymo struktūros: sąlyginis sakinys ir veiksmų kartojimas.
5.    Procedūros ir funkcijos.
6.    Duomenų struktūros: masyvas.
7.    Duomenų struktūros: įrašas.
8.    Tekstinės bylos.
9.    Programavimo technologija.
Programavimas – tai bendravimas su kompiuteriu tokia kalba, kuri suprantama ir kompiuteriui, ir juo dirbančiam žmogui. Labai svarbu suvokti programavimo esmę – keliolika pagrindinių konstrukcijų. Tuomet nei jo bijosime, nei jis stebins. Vaikui išmokti kalbą nebūtų sunku, jei jis turėtų tinkamas sąlygas. Mokytis kompiuterio kalbos reikėtų taip natūraliai, kaip mokomasi, pavyzdžiui, prancūzų šnekamosios kalbos Prancūzijoje, o ne taip, kaip jos mokoma Amerikos mokyklose. Kas sudaro tas tinkamas sąlygas? Pirmiausia – tai ugdymo filosofija, antra – pasirinkta programavimo kalba, trečia – tai mokymo metodika. Flash ActionScript – tai ir pedagoginė filosofija, ir programavimo kalba, ir mokymo metodika, tinkanti ne tik mokyklinio amžiaus vaikams, bet ir vyresniesiems. Todėl siūloma moksleivių algoritminį mąstymą papildomai ugdyti vaizdesne ir paprastesne Flash Actionscript sistema.
Tyrimo problema: Mokyklose moksleivių algoritmavimo įgūdžių ugdymui tiek dešimtose, tiek dvyliktose klasėse plačiai naudojama Turbo Pascal programa. Ši programavimo aplinka puikiai tinka supažindinti moksleivius su programavimo konstrukcijomis ir turint programavimo Paskaliu pagrindus nesunkiai galima išmokti ir kitos programavimo kalbos. Tačiau ši aplinka nėra vaizdinga ir išvedami į juodos spalvos ekraną programos rezultatai silpnesniems moksleiviams yra sunkiai suvokiami. Yra sunku suvokti kaip vyksta programa, matant tik galutinius rezultatus ekrane. Dvyliktose klasėse jau yra siūloma mokyti objektinio programavimo Delphi programavimo aplinka. Ši sistema yra daug vaizdingesnė ir įdomesnė moksleiviams. Kaip alternatyvą, algoritmavimo įgūdžių ugdymui galima naudoti ir Flash ActionScript programavimo kalbą. ActionScript – scenarijų programavimo kalba, naudojama interaktyviems Flash filmams kurti. ActionScript galima greičiau ir lengviau sukurti programas, nei naudojant įprastas kompiliuojamas kalbas, tokias kaip Pascal, C ar C++. ActionScript ypač efektyviai kuriamos trumpos programos. Ši programavimo aplinka yra kur kas vaizdingesnė. Kai kuriose situacijose, pavyzdžiui kintamųjų reikšmių priskyrime, galima vaizdžiai parodyti kaip vyksta programos kodas. Taip pat ši aplinka leidžia labai lengvai sukurti judesį. Ugdant algoritmavimo įgūdžius ActionScript, moksleiviai bus sudominti rezultatų vaizdumu, aplinkos interaktyvumu, todėl informacijos įsisavinimas gali būti efektyvesnis, nei dirbant vien tik Paskalio programa. Paskalio programa yra puiki priemonė algoritmavimo įgūdžių formavimui, tačiau jiems ugdyti ir plėsti programavimo žinioms galima panaudoti ir Flash ActionScript kalbą. Mokant Paskalio kalbą, visada bus nesunku išmokti ir kitą programavimo kalbą, tačiau dar vienos programavimo kalbos naudojimas tik sustiprins ir praplės moksleivių žinias programavimo srityje.
Hipotezė: Macromedia Flash ActionScript kalba ugdymo praktikoje gali būti panaudota  papildomam algoritmavimo įgūdžių ugdymui.
Tyrimo tikslas: Ištirti Macromedia Flash Script kalbos papildomo taikymo galimybes algoritmavimo įgūdžių ugdymui bendrojo lavinimo mokyklos informatikos pamokose bei atskleisti algoritmavimo ir programavimo Macromedia Flash sistemoje mokymo metodikos efektyvumą.
Tyrimo uždaviniai:
•    Apžvelgti programos Macromedia Flash ActionScript kalbos galimybes bei pagrindinius darbo su šia programa metodus.
•    Atlikti lyginamąją bendrojo lavinimo mokyklos dvyliktos klasės “Programavimo” modulio turinio, pritaikant jį Flash ActionScript aplinkoje, analizę.
•    Pateikti papildomam algoritmavimo įgūdžių ugdymui kiekvienos modulio “Programavimas” turinio dalies pritaikymo Flash ActionScript kalboje pavyzdžius.
•    Paruošti algoritmavimo ir programavimo Macromedia Flash Script sistemoje mokymo metodikos planą bei kiekvieno skyriaus uždavinius.
Tyrimo objektas: Macromedia Flash Script kalbos  panaudojimo papildomam algoritmavimo įgūdžių ugdymui galimybės.
Tyrimų metodika ir organizacija:
•    Modulio “Programavimas” turinys ištirtas naudojant informacinių šaltinių analizės metodą.
•    Programos Macromedia Flash Script kalbos galimybės išsiaiškintos informacinių šaltinių analizės metodo bei uždavinių nagrinėjimo pagalba.
•    Algoritmavimo ir programavimo Macromedia Flash Script sistemoje mokymo metodikos planas bei kiekvieno skyriaus uždaviniai paruošti naudojant informacijos šaltinių analizės metodą bei lyginamąją modulio “Programavimas” analizę.
Tyrimo rezultatai: Macromedia Flash Script kalbos galimybės, gali būti panaudotos papildomam algoritmavimo įgūdžių ugdymui. Naudojant vien tik Paskalio kalbą, programavimo įgūdžiai yra suformuojami, tačiau jiems įtvirtinti galima pasirinkti ir alternatyvią ActionScript scenarijų kalbą. Modulio “Programavimas” turinio dalys papildomai gali būti nagrinėjamos ir Flash programa. Jei tą pačią užduotį atliksime keliomis priemonėmis, tai žinių įsisavinimas bus daug efektyvesnis. ActionScript scenarijų rezultatai pateikiami vaizdžiai bei aiškiai ir moksleiviai algoritmavimo įgūdžius įsisavina efektyviai. Šiame darbe kiekvieną ActionScript kalbos nagrinėjamą dalį lydi aiškūs ir lengvai suprantami pavyzdžiai, bei pateikiami detaliai išnagrinėti uždaviniai. Pateikta medžiaga galės naudotis ne tik informatikos mokytojai, bet ir patys moksleiviai galės savarankiškai mokytis papildomai.
Darbo struktūra: Šį baigiamąjį darbą sudaro: įvadas, programos Macromedia Flash apibudinimas, pagrindinių darbo su Flash programos ActionScript kalba metodų apžvalga, pateikiami kiekvienos modulio “Programavimas” turinio dalies pavyzdžiai bei paruošti uždaviniai, tyrimo rezultatų analizė ir išvados.
Šiame baigiamajame darbe yra apžvelgiamos ActionScript kalbos struktūros, siūlomos Macromedia Flash 5 versijoje ir bandoma jas pritaikyti papildomam bendrojo lavinimo mokyklos dvyliktos klasės moksleivių algoritmavimo įgūdžių ugdymui, lyginant su Object Pascal kalbos struktūromis. ActionScript kalba analizuojama remiantis literatūros šaltiniais: Билл Сандерс “Эффективная работа Flash 5” ir Д. Α. Γурский, И. В. Горбач “Flash MX и ActionScript: обучение на примерах”. Išnagrinėta ActionScript kalba gali būti papildomai pritaikyta vidurinės mokyklos XII kl. mokiniams, pasirinkusiems kurso modulį „Programavimas“, bei mokytojams dėstantiems šį modulį. Mokymo medžiaga gali pasinaudoti ne tik mokiniai, bet ir visi, kurie nori susipažinti su programavimu Flash ActionScript kalba, bei darbo su Macromedia Flash 5 programos ypatumais.
Tikiuosi, kad šis darbas praplės mokytojų akiratį algoritmavimo įgūdžių ugdymo pasirenkant programavimo priemonę srityje ir jie ims plačiau taikyti įvairesnes ir vaizdesnes programavimo aplinkas, kurios palengvins moksleivių žinių įsisavinimą bei ugdys jų kūrybiškumą.

1. INTERAKTYVIOJI GRAFIKA – MACROMEDIA FLASH
1.1 FLASH PROGRAMOS ATSIRADIMO ISTORIJA

Interaktyvioji grafika paskutiniais metais pakeitė visą internetą: daugelis tinklapių tapo judresni, spalvingesni ir labiau orientuoti į vartotoją. Dar 1990 – jų metų viduryje Internetas buvo kaip didelė teksto jūra su keliomis iliustracijomis. Profesija “Web – dizaineris” dar tik gimsta. Tačiau viskas greitai keičiasi. Internetas pradeda užkariauti pasaulį. Vis daugiau žmonių trokšta pajusti laisvės iliuziją. Kartu su dideliu vartotojų antplūdžiu į tinklą įsiveržia ir internetinės parduotuvės, mokami tinklalapiai. Iškyla konkurencija, reklama. Norint klestėti, reikia išsiskirti. Vartotojui reikalinga atrakcija, kurios reikalauja ir reklamos užsakovai.  Prieš keletą metų pagrindinė judančios grafikos varomoji jėga buvo animuota gif grafika (animated gifs). Judančios grafikos technologija turi didelių trūkumų, kurie neleido šiai technologijai būti interneto tinklapių kūrimo pagrindu. Vienas didžiausių trūkumų yra tas, jog animuoti gif paveikslėliai užima labai daug vietos. Tai glūdi jų struktūroje: visas judantis paveiksliukas sudarytas iš kadrų, todėl kiekvienas kadras užima tiek atminties, kiek ir paprastas paveiksliukas.Naudojant tik HTML ir animuotus gif paveiksliukus, sunku sukurti kažką tokio, kas galėtų nustebinti vaizduotę. Žinoma dar yra ir Java, tačiau profesionalus programavimas – tai per daug brangus malonumas.
Macromedia kompanija šią problemą išsprendė, panaudodama vektorinę grafiką: paprasčiausiai yra sukuriami pradinis ir galutinis kadrai, o tarpinius kadrus sugeneruoja “Flash” programa, keisdama objektų dydį, spalvą, pasukimo kampą, judėjimą. Tokiu būdu jau nėra kuriami daug atminties užimantys kadrai, iš interneto vartotojas praktiškai parsisiunčia tik pradinį ir galutinį kadrus bei instrukcijas, kaip tuos kadrus generuoti. Taip kuriamos bylos užima daug mažiau vietos. Žinoma, “Flash” programa galima kurti ir vaizdus “kadras po kadro” būdu, tačiau tada prarandama galimybė sumažinti bylos dydį.
Jausdama rinkos reikalavimus Macromedia nupirko kompaniją Future Animation, kuri 1995 metais sukūrė nedidelę (3 Mb) programą FutureSplash Animator, skirtą animaciniams filmams kurti. Praplėtusi ją šalia specifinių tinkalapiams galimybių, Macromedia greitai išleido naują produktą – Flash (angl. tvykstelėjimas). Nežiūrint į pavadinimą, Flash pirma ir antra versija nesugebėjo “apakinti” savo galimybėmis programos vartotojų. Ir tik trečioji jos versija gavo vertą pripažinimą. Išleidus 3 Macromedia “Flash” versiją, ji tapo labai lengvai prieinamu ir pamėgtu įskiepiu (plug-in) visose interneto naršyklėse. Trečioje versijoje buvo galima sukurti nesudėtingą vektorinę animaciją, mygtukus ir interaktyvius elementus. Tam nereikėjo būti nei profesionaliu animatoriumi, nei patyrusiu programuotoju.
Su 4 versija Macromedia įtraukė ir skriptų (script) kalbą, kurią pavadino ActionScript. Iškilo unikalus grafikos, animacijos ir programavimo derinys vienos sistemos rėmuose, kuri žinoma kaip Macromedia Flash. Flash 5 versija turi perdarytą AcsionScript kalbą, kuri yra orientuota į objektinį programavimą ir panaši į JavaScript, taip pat turi integruotą programavimo aplinką. Tai reiškia, kad dabar Flash gali bendrauti su duomenų bazėmis, būti dinamiška ir sukurti pilnai išbaigtas programas.
Paskutinė Flash versija (Macromedia Flash MX) leidžia kurti daug įdomesnes ir daugiau interaktyvumo suteikiančias priemones, pasiūlyti originalias idėjas ir sprendimus, juos pritaikyti mokymui. Pavyzdžiui, naudojama muzika, įdomi animacija ir interaktyvūs judantys mygtukai intriguoja vartotoją tęsti programos peržiūrėjimą ir domėtis pateikiama informacija.
Galima drąsiai teigti, kad dabartiniu metu nėra kitos tokios priemonės, kuri suteiktų didelę laisvę kūrybai, kaip puikus kompanijos Macromedia kūrinys – programa Flash. Čia galima būti dailininku, animatoriumi, web-dizaineriu ir programuotoju vienu metu.

1.2 FLASH ACTIONSCRIPT

Iš pradžių Flash programa (kaip ir jos pirminė versija FutureSpalsh) buvo kompaktiška vektorinės animacijos technologija, skirta besiplečiančiam Pasauliniam tinklui. Jokių programavimo kalbos elementų pirmose programos versijose nebuvo. Tačiau jau trečioje Flash versijoje iškilo aiški priemonių, skirtų scenų ir mygtukų valdymui, atsiradimo sistemoje būtinybė. Ketvirtoje Flash versijoje pasirodė vertinga programavimo kalba – ActionScript. Tai tapo nedidele revoliucija Interneto pasaulyje.
ActionScript yra Flash skriptų kalba. Scenarijų kalba ActionScript nėra taip griežtai struktūrizuota ir  labai panaši Į JavaScript, bet daugiau yra orientuota į objektinio programavimo kalbą, kaip Java ar C++.
ActionScript kalbą galima naudoti objektų Flash filmuose kontrolei, judesio ir interaktyvių elementų kūrimui. Norint sustabdyti ar paleisti filmą, išjungti ar įjungti garsą, reikia naudoti skriptų kalbą. Šios parastos, bet svarbios funkcijos yra būtinos Flash dinamiškam filmui, norint užtikrinti bendravimą su vartotoju. ActionScript pagalba vartotojui gali būti leidžiama rinktis kur jis nori “eiti” ir kokius efektus įjungti, o kokius – išjungti. Ši scenarijų kalba gali būti taip pat vartojama objekto vietos nustatymui, jo veiksmų keitimui ir pan. Pavyzdžiui, žaidimo kūrėjui yra būtina suskaičiuoti žaidėjo surinktus taškus, gauti informaciją apie objektų susidūrimą ir nustatyti, kada keičiasi objekto pozicija. Flash ActionScript siūlo nepakartojamas naujas galimybes interaktyvių web-puslapių kūrimui su įmantriais žaidimais, naršymu, elektroninės komercijos kūrimu (įsigytų prekių sumai apskaičiuoti) ir realaus laiko dialoginėmis sistemomis, tokiomis kaip pokalbių svetainės.
Kurdama ActionScript, Macromedia kūrėjų komanda stengėsi vadovautis kai kuriais principais:
•    Prieinamumas. ActionScript turi būti paprasta žmonių supratimui, nesusieta su programavimu.
•    ActionScript, kaip pilnavertė scenarijų kalba, labai panaši į JavaScript, kuri yra faktiškai standartas scenarijams Internete. Todėl, žinant JavaScript, nebus sunku pereiti prie ActionScript, o atvirkščiai – išmokus programavimo Flash’e, bus lengviau įsisavinti bendresnes ir universalesnes kalbas.
•    Suderinamumas. Flash MX pilnai palaiko atgalinį didelio kiekio projektų, sukurtų ankstesnių ActionSAcript versijų pagalba, suderinamumą. Galima suderinti viename projekte Flash 4 sintaksę su penktos Flash versijos sintakse.
Scenarijų kalbos nuo pat pradžių buvo kuriamos taip, kad būtų kuo duagiau panašios į natūralias kalbas, ir nors ActionScript – tai hibridas tarp scenarijų kalbos ir tradicinės programavimo kalbos, ji yra labai paprasta mokymuisi. AcsionScript redaktorius AcsionScript kalbą daro daug paprastesnę, nei kitos programavimo kalbos. AcsionScript redaktorius automatizuoja beveik visą programavimo darbą. Norint kokį nors įvykį proskirti objektui, tereikia dukart spragtelėti pelyte ant norimo įvykio ir jis bus taisyklingai įterptas į scenarijų.

1.3 ACTIONSCRIPT SCENARIJŲ KŪRIMAS

Visi scenarijai yra susiję tam tikru kadru, mygtuku, ar scena. Netgi scenarijus, kurio veikimas yra skirtas visam filmui, įskaitant visas scenas, sluoksnius ir kadrus, turi būti susijęs su konkrečiu kadru, mygtuku ar scena. Pavyzdžiui, scenarijus, išjungiantis garsą visame filme vieno mygtuko paspaudimu.
ActionScript programos yra kuriamos scenarijų komandų išrinkimo iš sąrašo ir įdėjimo į mažus programinius modulius keliu. Jeigu yra pažymėtas kadras, atsiveria Frame Actions (veiksmai su kadrais) dialogo langas, o jei yra pažymėtas mygtukas ar scena – pasirodo Object Actions (veiksmai su objektais) dialogo langas. Spragtelėjimas du kartus pele ant kadro atveria Frame Actions (veiksmai su kadrais) dialogo langą, tačiau mygtuko ar kito objekto atveju, pažymėjus objektą, reikia parinkti meniu komandą Window → Actions, norint atverti Object Actions (veiksmai su objektais) dialogo langą.

Frame/Object Actions dialogo langai:
Dialogo lango Frame/Object Actions (veiksmai su kadru/objektu) kontekstas keičiasi priklausomai nuo to, kas yra išskirtas – kadras ar objektas. Dialogo lange yra ActionScript redaktorius, į kurį yra rašomas scenarijaus kodas (žr. 1 pavyzdys).
1 pavyzdys

Šį dialogo langą galima atverti parinkus meniu punktą Window → Actions, klavišų kombinacija Ctrl + Alt + A, ar mygtuko Show Actions (kuris yra programos lango dešiniajame apatiniame kampe ) pagalba. Veiksmų sąrašas yra prieinamas tik pažymėjus kadrą ar objektą. Veiksmus ir kitus ActionScript elementus galima įterpti į scenarijų įvairiais būdais:
1.    pernešimas – išsirinkus komandą, kurią norime įterpti į scenarijų, pernešame ją iš kairiojo dialogo lango į dešinįjį (ActionScript redaktoriaus langą);
2.    dvigubas pelytės spragtelėjimas – du kartus spragtelėjus pelyte ant scenarijaus elemento, jis atsiranda redaktoriaus kodo lange;
3.    išrinkimas iš meniu – tam reikia spragtelėti pelyte ant mygtuko su pliuso ženklu kairėje lango pusėje ir išrinkti reikalingą komandą atsivėrusiame meniu;
4.    tekstinis įvedimas – tiems, kurie turi programavimo patirties, labiau tinkamas yra eksperto rėžimas (normaliame rėžime Flash 5 neleidžia nieko įvesti rankiniu būdu redaktoriaus kodo lange). Paprasčiausiai surenkamas reikiamas kodas;
5.    kombinacija – eksperto rėžime galima kombinuoti visus išvardintus metodus.
Normali darbo aplinka:
Pradedant dirbti su ActionScript rekomenduojama scenarijus kurti normalioje darbo aplinkoje (Normal). Kai scenarijus yra kuriamas normalioje darbo aplinkoje, apatinėje lango dalyje pateikiami visi parametrai, būdingi konkrečiam scenarijaus elementui: įvykiui, funkcijai, operatoriui, savybei ar objektui. Scenarijus yra kuriamas atitinkamai pažymėtam objektui. Pavyzdžiui, komandai GoTo iš katalogo BasicActions (pagrindiniai įvykiai) prieinami parametrai ir sugeneruotas kodas yra skirtingi priklausomai nuo to, kam yra taikoma komanda GoTo: mygtukui –
on (release) {
gotoAndPlay (1);
}
klipui –
onClipEvent (load) {
gotoAndPlay (1);
}
ar kadrui –
gotoAndPlay (1);
Kadrai neturi įvykių, todėl ir jų scenarijuose nėra įvykių apdorojimo. Mygtuko įvykis – tai jo paspaudimas (release). Klipas yra susijęs su įvykiu paleidimas (load), kuris įvyksta kai klipas pasirodo filme ir vyksta labai panašiai kaip scenarijus, susijęs su kadru. Tačiau skirtingai nuo kadrų, klipai turi kitus įvykius, pavyzdžiui mouseDown ir mouseUp. Šie įvykiai įvyksta kai yra paspaudžiamas ar atleidžiamas pelės klavišas (analogiškai mygtukui). Tačiau mygtukas reaguoja tik į paspaudimą mygtuko srityje, o įvykiai mouseDown ir mouseUp, skirti klipui, įvyksta nepriklausomai nuo to , kurioje vietoje bus paspaustas pelės klavišas.
Normalioje darbo aplinkoje ActionScript redaktoriuje yra katalogas Basic Actions (pagrindiniai įvykiai), kuriame saugoma beveik pusė įvykių, kurie buvo naudojami Flash 4 versijoje. Jeigu bus naudojami įvykiai tik iš šio katalogo, tai failą bus galima eksportuoti be praradimų į Flash 4 formatą. Tarp penkių kitų katalogų ActionScript yra katalogas Actions (veiksmai), kuriame yra platesnis įvykių rinkinys, tačiau jie jau yra pristatomi naujame ActionScript formate.
Eksperto darbo aplinka:
Dirbant su programa Flash, dažnai tenka priskirti kelis įvykius ar funkcijas vienam ir tam pačiam mygtukui ar klipui. Naudojantis normalia darbo aplinka visada reikės pašalinti gausias eilutes on (release), kurios yra automatiškai įterpiamos į scenarijų. Kiekvieną kartą, kai normalioje darbo aplinkoje mygtukui ar klipui bus pridedamas naujas veiksmas, kartu bus pridedamas ir apvalkalas (antraštė ir uždarantys skliausteliai), nesvarbu ar jis jau yra scenarijuje.
Pasirinkus eksperto darbo aplinką (Expert), ActionScript redaktorius pakis priklausomai nuo išrinkto scenarijaus elemento. Pavyzdžiui, jei eksperto darbo aplinkoje dukart pelyte spragtelėsime ant veiksmo gotoAndPlay, tai išvysime: gotoAndPlay (    ). Tušti skliausteliai rodo, kad šioje vietoje reikia įvesti tam tikrą parametrą, susijusį su kadru, bet pats redaktorius neįves jokios pagalbinės informacijos apie parametrus. Eksperto darbo aplinkoje parametrus reikia įvesti rankiniu būdu. Šią aplinką patartina naudoti tada, kai turima pakankamai patirties dirbant su ActionScript ir funkcijų parametrai bei įvykiai tampa visiškai suprantami. Tačiau neturintiems pakankamai įgūdžių rekomenduojama normali darbo aplinka, kuri taupo laiką ir neleidžia padaryti nereikalingų klaidų.
Skripto rašymas:
Paprastus skriptus galima pradėti rašyti neturint daug žinių apie ActionScript. Svarbiausia yra uždavinys ir teisingų veiksmų parinkimas. Geriausias būdas pamatyti ActionScript paprastumą yra skripto sukūrimas. Toliau pateikiamas scenarijaus mygtukui pavyzdys, kuris keičia filmo klipo matomumą.:
1.    Pasirinkite Window→CommonLibraries→Buttons (Langas→Pagrindinės bibliotekos→ Mygtukai) meniu komandą ir iškelkite pasirinktą mygtuką ant scenos. Tada parinkite Window→CommonLibraries→Movie Clips  (Langas→Pagrindinės bibliotekos→Filmo klipai) ir patalpinkite ant scenos filmo klipą.
2.    Pažymėkite filmo klipą ant scenos ir parinkite komandą Window→Panels→Instance (Langas→Paneliai→Pavyzdys).
3.    Vardo (Name) lauke įveskite klipas.
4.    Pažymėkite mygtuką ir pasirinkite Window→Actions (Langas→Veiksmai), kad atvertumėte Actions (veiksmai) dialogo langą.
5.    Object Actions (veiksmai su objektais) dialogo lange pelyte paspauskite Actions katalogą ir jį atverkite.
6.    Dukart pelyte paspauskite setProperty (nustatyti savybę) veiksmą. Taip jį įtrauksite į kuriamą scenarijų.
7.    Iš Property (savybė) pasirinkimo meniu išrinkite savybę _visible (matomumas).
8.    Target (objektas) parametrui įveskite klipas.
9.    Reikšmės (Value) parametrą įveskite 0.
Kodas turi atrodyti taip:
on (release) {
setProperty (“klipas”,_visible,0);
}
10.    Parinkite komandą Control→Test Movie ir paspauskite filmo mygtuką, kad pamatytumėte kaip išnyksta filmo klipas.
ActionScript scenarijų kalba yra orientuota į objektinį programavimą. Tai reiškia, kad veiksmai kontroliuoja objektus kai įvyksta konkretus įvykis. Šiame scenarijuje įvykis yra pelės paspaudimas, objektas – filmo klipo pavyzdys “klipas”, ir veiksmas yra setProperty (nustatyti savybę). Kai vartotojas paspaudžia mygtuką ekrane, release (vykdymo) įvykis iškviečia scenarijų, kuris objekto “klipas” savybę _visible (matomumas) nustato į false ir priverčia objektą tapti nematomu.
1.4 OBJEKTIŠKAI – ORIENTUOTAS ACTIONSCRIPT MODELIS

Objektiškai – orientuotas programavimas (OOP) – tai pakankamai jauna koncepcija, įgavusi platų pasiskirstymą nuo 1980 –tų metų vidurio, palaikanti kalbų Smalltalk, C++ ir Objektinis Paskalis apdorojimo procesą. Esminė OOP dalis yra objektas.
Objektas – tai kintamųjų, įvardijančių reikalingus duomenis, ir priemonių darbui su tais duomenimis rinkinys. Darbo priemonės vadinamos metodais (“Programavimas Delphi”, 250). Objektas – tai abstrakcija, reiškianti bet kokį daiktą ar sąvoką. Pavyzdžiui, einantis per stogą katinas – tai objektas. Jis turi savybes: spalvą, amžių, dydį ir t.t. Katino savybės dalijasi į individualias (pavyzdžiui, akių spalva) ir būdingas visiems katinams (programavime vadinamas klase), (pavyzdžiui, širdies sandara). Tačiau katinų klasė yra daug kuo panaši į žinduolių klasę (pavyzdžiui, kojų skaičiumi), vadinasi yra jos poklasis. Bet kuri klasė gali turėti poklasį, paveldėjantį jos savybes. Pavyzdžiui į sąvoką “naminis katinas” įeina tūkstančiai skirtingų veislių. Katinui būdingi metodai – algoritmai, keičiantys jo savybes. Pavyzdžiui, šaldytuvo durų trinktelėjimas – metodas, keičiantis katino padėties savybes į reikšmes, sutampančias su virtuvės koordinatėmis.
Pagrindinė objekto savybė yra inkapsuliacija. Tai kintamųjų ir jų reikšmių (duomenų) apdorojimo priemonių (metodų) visuma (“Programavimas Delphi”, 250). Norint pakviesti augintinį pietauti, nebūtina žinoti jo anatomijos ir nervinės sistemos ypatumų. Tam užtenka turėti metodą “kis-kis”.
Į vieno ir to paties metodo veikimą skirtingi katinai gali skirtingai reaguoti. Išgirdęs šuns lojimą, atsargesnis gyvūnas įlips į medį, o drąsesnis toliau miegos.  OOP terminais toks vienos klasės objektų elgesys vadinamas polimorfizmu.
Keletas objektų, turinčių vienodas savybes, sudaro klasę. Įsivaizduokime, kad kuriame rudeninę aikštelę, ant kurios krenta skirtingi lapai. Jie atrodo skirtingai, bet jų judėjimas aprašomas vienu ir tuo pačiu metodu. Būtų neracionalu kiekvienam lapui rašyti atskirą scenarijų. Geriau yra nurodyti, kad duotasis objektas (lapas) turi judėti pagal principus, aprašytus visų tipų lapams ankščiau. Todėl nupieštas grafinis objektas turi būti įregistruotas kaip atitinkamos klasės egzempliorius. Toks metodas leidžia sumažinti programos dydį ir laiką, reikalingą jos sukūrimui.
Asmeninės vartotojo klasės yra sukuriamos funkcijų-konstruktorių pagalba:
function MyObj () {
this.name = “nauja klasė”;
this.properties = “Tik vardas”;
}
Obj1 = new MyObj (); // sukuriamas naujos klasės MyObj objektas
trace (“Klasės vardas: “ + Obj1.name); // Išveda “Klasės vardas: nauja klasė”
trace (“Savybė: “ + Obj1.properties); // Išveda “Savybė: Tik vardas”

Kiekvienam objektui būdingos savybės ir metodai:
Savybės yra įvardintos duomenų saugyklos, susijusios su objektu. Jos yra panašios į masyvo elementus ir gali saugoti bet kokio tipo duomenis: eilutes, skaičius, loginius dydžius, klipus, funkcijas ir t.t. Pasiekti kokią nors savybę galima naudojant operatorių “taškas” (.).
trace (ball._vivible); // jei objektas ball yra matomas, tai rezultatas bus “true”. Pavyzdžiui, norėdami mygtuko paspaudimu pakeisti filmo klipo “zuvis” padėtį ekrane, mygtukui turime priskirti sekantį kodą:
on (release) {
zuvis._x+=10;
zuvis._y+=10;
}
ActionSript kalboje tiesiogiai galima kreiptis (ir keisti) tik į klasės MovieClip objektų savybes. Ši klasė yra ypatinga, privilegijuota. Visoms kitoms klasėms (Sound, Color, Array, String ir kt.) charakteringa tai, kad perskaityti (ar pakeisti) savybes galima tik specialių metodų pagalba. To reikalauja inkapsuliacijos principas. Pavyzdžiui, negalima sumažinti garso garsumo, kreipiantis tiesiogiai į atitinkamą savybę:
SOUND1.volume = 50;
Pateiktos užduoties įvykdymui reikia naudoti metodą setVolume( ):
SOUND1.setVolume(50);
Analogiškai, norint sužinoti esamą garsumo reikšmę, reikia kreiptis į metodą getVolume( ).
Bet kuriam objektui gali būti priskirta nauja savybė. Pavyzdžiui, norint nurodyti, kad tam tikras klipas Mov yra sukurtas programiškai, rašome:
Mov.prog = true;
trace (Mov.prog); // išveda “true”
Tokio tipo savybes galima laikyti ir kaip kintamuosius, “prijungtus” prie klipo. Bet kokios savybės ir yra kintamieji, kurių interpretacija daro, pavyzdžiui, kamuolį permatomu ar ištemtu.
Metodai – tai funkcijos, susietos su objektu ir naudojamos tam tikrų užduočių vykdymui (play ( ) ) arba savybių keitimui (setVolume ( ) ). Metodai, būdami objekto vidinės struktūros dalimi, panašiai kaip ir savybės, iškviečiami operatoriaus “taškas” (.) pagalba. Tačiau, bet kuris metodas – tai funkcija, todėl jame turi būti atitinkamas iškvietimo operatorius “( )”:
ball.gotoAndStop ( ) ;
Praktiškai visos klasės turi įterptus metodus, būdingus visiems jų egzemplioriams. Tačiau galima “prijungti” konkrečiam objektui jo savus metodus. Tam užtenka “priskirti” jam atitinkamą funkciją:
function name ( ) {
trace (“Šokinėjantis kamuolys”)
}
ball.NAME = name;
ball.NAME ( ) ; // išveda “Šokinėjantis kamuolys”
Galima vienu metu priskirti kai kurį metodą ar savybę visoms ActionScript klasėms. Metodas ar savybė turi būti “pritvirtinta” prie klasės Object konstruktoriaus, kuri yra visų likusių klasių viršklasis (jos paveldi Object klasės charakteristikas):
Object.prototype.Pi = 3.14;
S = new Sound ( );
X = new XML ( );
trace (“Savybė Pi klasės Sound = “ + S.Pi); // išveda “Savybė Pi klasės Sound = 3.14”
trace (“Savybė Pi klasės XML = “ + X.Pi); // išveda “Savybė Pi klasės XML = 3.14”.
OOP nėra sudėtingas ir nesuprantamas paprastam vartotojui. Galima kurti savo klases, objektus ir metodus, kurie nesiskirs nuo parašytų Macromedia programuotojų.

2. PAGRINDINIAI DARBO SU ACTIONSCRIPT METODAI
2.1 ACTIONSCRIPT SINTAKSĖ

ActionSript turi gramatikos taisykles ir skyrybos ženklus, kurios sąlygoja kokie ženklai ar žodžiai yra naudojami ir kokia tvarka jie gali būti rašomi. Pavyzdžiui, anglų ar lietuvių kalboje taškas užbaigia sakinį. ActionScript sakinį užbaigia kabliataškis (;). Toliau pateikiamos taisyklės yra ActionSript bendrosios taisyklės.
Taško sintaksė:
ActionSript taškas (.) naudojamas savybių ar metodų, susijusių su objektu ar filmo klipu, nurodymui. Jis taip pat naudojamas filmo klipo ar kintamojo kelio adresavimo nustatymui. Taško sintaksės išraiška prasideda  objekto ar filmo klipo vardu, esančiu prieš tašką, ir baigiasi savybe, metodu ar kintamuoju, kurį norima apibrėžti. Pavyzdžiui, _x filmo klipo savybė apibrėžia filmo klipo poziciją x ašyje. Išraiška zuvis._x nurodo filmo klipo “zuvis” savybę (padėtis x ašyje).

Įstrižo brūkšnio (slash) sintaksė:
Slash sintaksė buvo naudojama Flash 3 ir 4 versijoje filmo klipo ar kintamojo maršruto adresui nurodyti. Ši sintaksė vis dar yra palaikoma Flash 5 versijoje, bet jos vartojimas nerekomenduojamas. Slash sintaksė, įstriži brūkšniai (/) naudojami vietoje taškų filmo klipo ar kintamojo kelio nurodymui. Norint nurodyti kintamąjį, jis pateikiamas su dvitaškiu (:):
myMovieClip/childMovieClip:myVariable
Tą patį maršrutą galima užrašyti ir taško sintaksėje:
MyMovieClip.childMovieClip.myVariable

Figūriniai skliausteliai ( { } ):
ActionSript sakiniai grupuojami į blokus, apgaubtus figūriniais skliaustais:
on (release) {
a=10;
b=5;
c=a+b;
}
Kabliataškiai:
ActionSript sakinys yra užbaigiamas kabliataškiu, bet jei praleidžiame sakinį užbaigiantį kabliataškį, Flash vis tiek sukompiliuoja scenarijų sėkmingai. Pavyzdžiui, sekantys sakiniai yra užbaigiami kabliataškiais:
column = passedDate.getDay ( );
row = 0;
Tie patys sakiniai gali būti parašyti ir be kabliataškių gale:
column = passedDate.getDay ( )
row = 0
Lengtiniai skliaustai ( () ):
Kai yra apibrėžiama funkcija, bet kokie argumentai turi būti rašomi lenktinių skliaustų viduje:
function myFunction (name, age) {
………..
}
Kreipiantis į funkciją, taip pat bet kokie argumentai perduodami funkcijai skliaustuose:
myFunction (“Petras”, 10);
Taip pat lenktiniai skliaustai naudojami aritmetinių veiksmų tvarkai nurodyti:
total = (2 + 4) * 3;
Didžiosios ir mažosios raidės:
Tik baziniai žodžiai ActionSript reaguoja į didžiąsias ar mažąsias raides. Likusiai Actionsript daliai didžiąsias ir mažąsias raides galima naudoti savo nuožiūra. Pavyzdžiui, sekantys sakiniai yra lygiareikšmiai:
cat.hilite = true;
CAT.hilite = true;
Nenaudojant teisingų raidžių baziniuose žodžiuose, skriptuose gali būti klaidų. Kai Actions dialogo lange yra įjungta ColoredSyntax (spalvota sintaksė), taisyklingi baziniai žodžiai rašomi mėlyna spalva.
Komentarai:
Actions redaktoriaus dialogo lange norint įterpti komentarus, reikia parinkti Actions (veiksmai) → comment (komentaras) komandą. Komentarai leidžia lengviau suvokti ir sekti nustatytus veiksmus, ir yra naudingi informacijos perdavimui kitiems vartotojams, jei dirbama bendradarbiaujant ar yra pateikiami pavyzdžiai. Pasirinkus comment (komentaras) veiksmą, į scenarijų įterpiami ženklai //. Net paprastas skriptas yra lengviau suprantamas, jeigu jį kuriant rašomi komentarai:
on (release) {
//sukuria naują date objektą
myDate = newdate ();
currentMonth = myDate.getMonth ();
//konvertuoja mėnesio numerį į mėnesio pavadinimą
monthName = calcMonth (currentMonth);
}
Komentarai skripto redaktoriaus lange rašomi rožine spalva.
Konstantos:
Konstanta yra savybė, kurios reikšmė niekada nesikeičia. Konstantos yra išvardintos Action įrankių juostoje ir ActionSript Dictionary (žodyne). Suprantamos tik visomis didžiosiomis raidėmis. Pavyzdžiui, konstantos BACKSPACE (grąžinamasis klavišas), ENTER (įvesties klavišas), SPACE (tarpo klavišas) ir TAB (tabuliatorius) yra Key (klavišo) objekto savybės ir taikomos klaviatūros klavišams. Norint patikrinti, ar vartotojas spaudžia Escape klavišą, reikia parašyti sekantį kodą:
if(keycode() == Key.ESCAPE){
zuvis.gotoAndStop (1); // čia “zuvis”filmo klipas
}
2.2 KINTAMIEJI

Kintamasis yra rezervuaras, kuris saugo informaciją. Pats rezervuaras visada yra toks pats, bet jo turinys gali keistis.
Object Pascal kalboje visi programų kintamieji turi būti aprašyti nurodant jų vardus ir tipus, pavyzdžiui: suma: integer; a, b, c: real. Šie aprašai nurodo, kad kintamasis suma gali įgyti tik sveikųjų skaičių reikšmes, kintamieji a, b, c – realiųjų skaičių reikšmes. Kai kuriais atvejais reikalingi ir vidiniai procedūrų ir funkcijų kintamieji. Tokie kintamieji aprašomi pradedant žodžiu var, pavyzdžiui: var x: real (“Programavimas Delphi”, 24). Kintamieji programos vykdymo metu gali įgyti skirtingas reikšmes, tačiau jų tipo pakeisti negalima. Išimtis yra realiojo tipo kintamieji. Realiojo tipo kintamajam gali būti priskirta sveikojo tipo reikšmė (ji automatiškai pakeičiama realiąja).
ActionScript kalboje pirmą kartą aprašant kintamuosius rekomenduojama kintamajam priskirti žinomą reikšmę. Tai daroma pirmame filmo kadre ir yra vadinama kintamojo aprašymu. Kintamieji gali saugoti bet kokio tipo duomenis: skaičius, eilutes, logines reikšmes, objektus, ar filmo klipus. Kintamasis duomenų tipą saugo priklausomai nuo to, kaip keičiasi kintamojo reikšmė scenarijuje. Tipiškus duomenų tipus galima saugoti kintamajame, įskaitant URL, vartotojo vardą, matematinės operacijos rezultatą, skaičių kiek įvykis įvyko, ar mygtukas buvo paspaustas. Kiekvienas filmo ar filmo klipo pavyzdys turi savą kintamųjų aibę, kurioje kiekvienas kintamasis turi savo reikšmę nepriklausomą nuo kintamųjų kituose filmuose ar filmų klipuose. Kintamieji žymimi vardais, jie įgyja reikšmes.
Griežtai tipizuotos kalbos, tokios kaip C++, reikalauja iš programuotojo iš anksto nurodyti kokius duomenų tipus saugos kintamieji – tekstą, sveikąjį ar realųjį skaičių. Actionscript, kaip ir beveik visos scenarijų kalbos, to nereikalauja. ActionScript automatiškai nustato duomenų tipus, saugomus kintamuosiuose.
Kintamųjų vardai:
Vardas, kurį suteikiame kintamajam, turi atspindėti tai, kam duotasis kintamasis yra skirtas. Tokie vardai kaip KintamasisA ir KintamasisB mažai ką pasako. O vardai Suma ar Kaina parodo ką saugo kintamieji ir dėka tokių prasmingų kintamųjų vardų yra lengviau juos surasti, įsiminti ir naudoti. Flash programoje yra labai svarbu kintamiesiems suteikti aiškius vardus, nes dažniausiai scenarijai būna trumpi ir išmėtyti po visą filmą. Pavyzdžiui, jeigu programoje, susijusioje su mygtuku, naudojame kintamąjį B, o kitą kintamąjį, esantį kadro scenarijuje, taip pat pavadinsime B, tai yra labai didelė konflikto galimybė. Ir mygtuko, ir kadro scenarijai gali kreiptis į vieną ir tą patį kintamąjį B (jei tik abu scenarijai nenaudoja kintamojo šiuo vardu kaip lokalaus (vietinio)). Todėl tokio tipo vardai ne tik nėra informatyvūs, bet dar ir padidina konflikto galimybę.
Kintamųjų vardai turi būti vienos eilutės, susidedantys iš leidžiamų simbolių be tarpų. Vardai Mano vardas ar Petras Petraitis nėra leidžiami (juose yra tarpo simbolis), bet ManoVardas, Mano_Vardas ar manovardas gali būti naudojami. ActionSript neišskiria didžiųjų ir mažųjų raidžių vartojimo kintamųjų varduose. Jei kintamajam buvo suteiktas vardas Petras, tai į jį galima kreiptis vardais PETRAS ar petras. Tačiau Pet_ras – tai jau kitas kintamasis, nes jo varde yra vienas skirtingas simbolis – brūkšnelis. Didžiųjų ir mažųjų raidžių neskirimas ActionSript gali palengvinti kreipimąsi į kintamuosius, tačiau reikia būti atsargiems, kad skirtingiems kintamiesiems nesuteikti to pačio vardo. Pavyzdžiui, suteikus kintamiesiems SUMA ir suma vardus, galima manyti, kad jie yra skirtingi, tačiau ActionSript laikys juos vienodais.
Kintamojo aprašymas:
Flash programoje nereikia tiksliai aprašyti kintamojo kaip saugančio skaičių, eilutę, ar kitą duomenų tipą. Flash apibrėžia kintamojo duomenų tipą, kai kintamajam yra priskiriama reikšmė:
x = 3;
Išraiškoje x = 3, Flash nustato elementą dešinėje operatoriaus pusėje ir apibrėžia, kad tai yra skaitinio tipo kintamasis. Tolesnis kintamojo priskyrimas gali keisti x tipą, pavyzdžiui,  x = “labas” keičia x tipą į simbolių eilutę. Kintamasis, kuriam nebuvo priskirta reikšmė, turi tipą undefined (neapibrėžtas).
Actionsript duomenų tipus konvertuoja automatiškai, kad to reikalauja tam tikra išraiška. Pavyzdžiui, išraiškoje su operatoriais, kai + operatorius naudojamas su eilute, Actionscript tikisi kito operando – eilutės:
“Kitas skaičius “ + 7
ActionSript konvertuoja skaičių 7 į simbolių eilutę “7” ir prideda ją prie pirmos eilutės galo: “Kitas skaičius 7”.
Norėdami sužinoti kintamojo tipą, galime naudoti operatorių typeof, pavyzdžiui;
trace (typeof (kintamojo vardas));
Objektas new Number naudojama, norint konvertuoti simbolių eilutę į skaitinę reikšmę, pavyzdžiui:
on (release) {
skaicius=new Number (skaicius);
skaicius=skaicius+skaicius;
} //įvedus į tekstinį lauką (skaicius) reikšmę 4 ir paspaudus sukurtą mygtuką, rezultatas bus lygus 8.
Objektas new String naudojamas, norint konvertuoti skaitinę reikšmę į simbolių eilutę, pavyzdžiui:
on (release) {
tekstas=new String (tekstas);
tekstas=tekstas+tekstas;
} //įvedus į tekstinį lauką (tekstas) reikšmę 4 ir paspaudus sukurtą mygtuką, rezultatas bus ‘44’.

Kintamojo veikimo sritis:
Kintamojo veikimo sritis vadinama sritis, kurioje kintamasis yra žinomas ir gali būti prieinamas. Kintamieji Actionsript gali būti globalūs (visuotiniai) arba lokalūs (vietiniai). Globalus kintamasis yra prieinamas visose laiko juostose (Timelines); lokalus kintamasis yra prieinamas tik tame kodo bloke (tarp figūrinių skliaustelių), kuriame jis yra aprašytas.
Norint apibrėžti lokalų kintamąjį, galima naudoti var sakinį scenarijaus viduje. Pavyzdžiui, kintamieji i ir j dažnai naudojami kaip ciklo skaitliukai.
Globalūs kintamieji: kiekvienas kintamasis turi savo veikimo sritį: arba visą filmą, arba jo dalį. Iki Flash 5 versijos kintamieji ActionSript buvo tik globalūs. Šiuo atveju į kintamąjį buvo galima kreiptis bet kokiu atveju ir bet kurioje scenoje. Tai tinka ir Flash 5, bet šioje versijoje jau egzistuoja ir globalūs, ir lokalūs kintamieji. Globalūs kintamieji yra tokie kintamieji, kurie aprašomi set variable (Actions→set variable)veiksmo pagalba. Pavyzdžiui:
kintamasis = išraiška;
tekstas=’as’;
Kiekvienas objektas gali pakeisti globalaus kintamojo reikšmę, ir bet kuris globalus kintamasis gali turėti įtakos objektui.
Lokalūs kintamieji: lokalūs kintamieji – tai kintamieji, apibrėžti scenarijaus viduje išraiškoje var. Kai kintamasis aprašomas var pagalba tarp figūrinių skliaustelių, apribojančių scenarijų, tai į jį galima kreiptis tik šio scenarijaus viduje. Pavyzdžiui, nesvarbu kada bus įvykdytas mygtuko paspaudimas, yra vykdomas kodo blokas, esantis tarp figūrinių skliaustelių:
on (release) {
var demuo1=5;
var demuo2=15;
suma = demuo1+demuo2;
}
Turint lokalius kintamuosius, galima vartoti vienodus scenarijus daugeliui filmo mygtukų (tiesiog kopijuojant visą scenarijų į naują vietą). Lokalių kintamųjų reikšmės negali būti perskaitytos ar pakeistos kitų scenarijų. Pateiktame pavyzdyje išimtis yra kintamasis suma, jis yra globalus.
Lokalūs kintamieji gali padėti išvengti vardų kolizijų (susikirtimų). Pavyzdžiui, jei naudojamas kintamasis demuo1 kaip lokalus kintamasis, tai jį galima naudoti ir kaip kitų kintamųjų vardą, kadangi šie kintamieji bus vykdomi skirtingose srityse ir kolizijos nebus.

Kintamųjų aprašai:
Globalūs kintamieji gali būti aprašomi priskyrimo operatoriaus (=) pagalba arba naudojant setVariables veiksmą. Jei pasirinksite priskyrimo operatorių (=), tai rankiniu būdu turėsite priskirti kintamajam reikšmę, į scenarijaus langą bus įterptas tik priskyrimo operatorius. Jei pasirinksite veiksmą setVariables, tai bus įterptas visas priskyrimo sakinio šablonas (<not set yet> = “”;). Jums reikės dialogo lango Object Actions apatinėje dalyje įvesti kintamąjį (Variable) ir jo reikšmę (Value). Abu metodai duoda tą patį rezultatą. Pavyzdžiui:
x=’Labas’;
Lokalūs kintamieji aprašomi operatoriumi var funkcijos viduje. Pavyzdžiui: var x;
Norėdami patikrinti kintamojo reikšmę, naudokite veiksmą trace. Šis veiksmas nusiunčia kintamojo reikšmę į išvedimo langą (Output). Pavyzdžiui, trace (x) siunčia kintamojo x reikšmę į išvedimo langą test-movie rėžime.
on (release) {
x = “Labas”;
trace (x);
}
Ekrane, testuodami filmą ir paspaudę mygtuką, matysite tokį vaizdą:

2.3 DUOMENŲ TIPAI ACTIONSRIPT

Duomenų tipai apibūdina kokio tipo informaciją gali saugoti kintamasis. ActionScript naudoja tokius pat duomenų tipus kaip ir įprastos programavimo kalbos. Pagrindiniai duomenų tipai yra eilutės, skaičiai (sveikieji, realieji), išraiškos ir loginės išraiškos. Kiekvienas duomenų tipas turi savo taisykles.
Skaičiai:
Object Pascal kalboje dažniausiai vartojami dviejų rūšių skaičiai – sveikieji (integer) ir realieji (real). Sveikasis skaičius – tai skaičius, neturintis trupmeninės dalies (5, 0, -13). Visi kiti skaičiai laikomi realiaisiais (5.5, 0.0, -10.0). Su skaičiais atliekamos įprastos aritmetinės operacijos: sudėtis,atimtis, daugyba, dalyba bei lyginimas. Tačiau dalybos operacijos yra net trijų rūšių. Operacija div vartojama, kai norime gauti sveikojo skaičiaus dalmenį; operacija mod – kai norime gauti sveikojo skaičiaus dalybos liekaną; įstrižu brūkšniu ( / ) žymima realiųjų skaičių dalyba ir jos rezultatas visuomet realusis skaičius (“Programavimas Delphi”, 51).
ActionSript kalboje skaičiai – tai patys paprasčiausi kintamieji. Skaičiai turi būti rašomi be kabučių. Neteisingų simbolių naudojimas skaičiuose gali sudaryti įvairių problemų, nes ActionScript bandys interpretuoti tokį “žodį” kaip kintamojo vardą. Kintamasis, apibrėžtas kaip skaičius, yra skaitinis kintamasis ir turi visas skaičių savybes. Skaitiniai kintamieji gali įgyti tiek teigiamas, tiek neigiamas reikšmes. Su skaitiniais kintamaisiais atliekamos aritmetinės operacijos (sudėtis (+), atimtis (-), daugyba (*), dalyba (/), modulis (%), didinimas (++), mažinimas (–). Taip pat galima naudoti matematinius metodus, pavyzdžiui skaičiaus kvadratinę šaknį:
Math.sqrt (100);
Visus matematinius metodus (sin, cos, min, max ir t.t.) galima rasti Object Action dialogo lange Objects.Math dalyje.
Sveikieji skaičiai – tai skaičiai be trupmeninės dalies. Apibrėžiant kintamuosius, nereikia nurodyti kokio tipo kintamąjį naudojame (sveikąjį ar realųjį), jei tai nėra būtina. Tačiau kartais yra būtina žinoti kokio tipo yra kintamasis. Pavyzdžiui, norint nurodyti, kad naudosime sveikojo tipo kintamąjį Sveikasis, galima parašyti taip:
Sveikasis = Math.round (x/y)
Išraiška x/y reiškia, kad kintamojo x reikšmė yra dalinama iš kintamojo y reikšmės. Iš anksto nėra žinoma, koks bus šios dalybos rezultatas: sveikasis skaičius ar ne. Operatorius Math.round ( ) leidžia suapvalinti gautąjį rezultatą iki sveikojo skaičiaus. Jei trupmeninė dalis didesnė ar lygi 0.5, tai skaičius bus suapvalintas iki artimiausio didesnio sveikojo skaičiaus. Priešingu atveju trupmeninė dalis bus tiesiog atmetama. Pavyzdžiui, 7.3 bus suapvalintas iki 7, o 7.7 ir 7.5 – iki 8.
Flash filmuose sveikieji skaičiai yra būtini, pavyzdžiui, sudarant ciklus. Kadrų numeriai taip pat yra sveikieji skaičiai. Jei išskiriant kadro numerį naudojame išraišką,reikia užtikrinti, kad rezultatas būtų sveikasis skaičius, nurodantis reikalingą kadrą.
Realieji skaičiai. Nors skaičiavimuose vartojami sveikieji skaičiai, rezultatas gali būti ir realusis skaičius. Net ir po apvalinimo operatoriaus naudojimo, tolesniuose skaičiavimuose sveikasis skaičius gali virsti realiuoju. Pavyzdžiui:
Sveikasis = Math.round (x/y);
Realusis = Sveikasis / 7;
Jei kintamasis Sveikasis nesidalina iš 7 be trupmeninės dalies, tai kintamasis Realusis turės ir trupmeninę dalį, nors ir Sveikasis, ir 7 yra sveikieji skaičiai.
ActionScript kalboje dalybos operacija yra tik viena ir čia negalime atskirti dalmens bei dalybos liekanos. Taip pat reikia akcentuoti, kad realiuose skaičiuose Object Pascal kalboje trupmeninė dalis nuo sveikosios atskiriama tik tašku. Tuo tarpu ActionScript kalboje atskyrimui galima naudoti ir tašką ir kablelį. Jei trupmeninę dalį atskirsime tašku, tai programa supras kaip realųjį skaičių, tačiau jei naudosime kablelį – trupmeninė skaičiaus dalis bus atmesta ir skaičiaus kintamasis virs sveikojo tipo kintamuoju.
Eilutės:
Eilutė – tai duomenų tipas, tarnaujantis tekstinės informacijos saugojimui. Eilutė yra raidžių, skaičių ir skyrybos ženklų simboliai. Kintamasis, kuris yra eilutės tipo, vadinamas eilutės kintamuoju.
Object Pascal  kalboje eilutės tai yra simbolių masyvai. Simbolių masyvai aprašomi žodžiu String, o elementų tipas nurodomas simbolinis – char. Pavyzdžiui:
type String = array [0..100] of char;
Su eilutėmis galima atlikti įvairiausius veiksmus. Norint sužinoti eilutės ilgį, kaip ir Actionscript kalboje, vartojama standartinė funkcija Length. Simbolinio tipo reikšmes galima įvesti klaviatūra bei išvesti reikšmes. Simboliai rašomi tarp kabučių (Programavimas Delphi, 125).
ActionScript sakinyje eilutės yra įvedamos apgaubiant jas viengubomis ar dvigubomis kabutėmis. Du skirtingi operatoriai (viengubos ir dvigubos kabutės) eilučių sukūrimui reikalingi tuo atveju, jei eilutės tekste jau yra kabutės. Pavyzdžiui:
tekstas =  ““Garis Poteris” – populiari knyga”;
Šiuo atveju bus išvedamas pranešimas apie klaidą. Teksto fragmentai nuo pirmos išorinės kabutės iki pirmos vidinės ir nuo antros vidinės iki antros išorinės bus suprantami kaip atskiros eilutės. Sistema negalės interpretuoti tokios situacijos teisingai. Tačiau galima panaudoti skirtingus simbolius vidinių ir išorinių kabučių pavidale:
tekstas =  ‘“Garis Poteris” – populiari knyga’;
Tačiau eilutės tekste gali būti ir paprastos, ir dvigubos kabutės (pvz.: Aš pasakiau: “Good day, isn’t it”). Tokiais atvejais reikia “paslėpti” nuo interpretatoriaus ženklus, suprantamus kaip operatorius, simbolio “\” pagalba (programavimo terminais tokios sistemos vadinamos escape – išvengimo):
tekstas =  ‘Aš pasakiau: “Good day, isn\’t it”’;
Apgaubus tekstą kabutėmis, sukuriamas naujas klasės String objektas. Eilutės tipo kintamajam reikšmę galima priskirti sekančiu būdu:
tekstas = ‘Laba diena’;
arba
tekstas = “Laba diena”;
Čia tekstas – kintamojo vardas, o Laba diena – jo reikšmė. Flash programa vienodai supranta viengubas ir dvigubas kabutes, tai yra jei simbolių eilutė yra apgaubta viengubų ar dvigubų kabučių, tai ji priskiriama String klasės objektui. Aprašyti eilutę galima ir konstruktoriaus new pagalba:
tekstas = new String (‘Laba diena’);
Norint aprašyti tuščią eilutę, ją sukurti galima įvedant porą kabučių:
tekstas = “”;
Eilutė gali susidaryti ne tik iš raidžių ir skaitmenų, bet ir iš skyrybos ženklų bei tarpų. Raidės, skaitmenys ir skyrybos ženklai gali būti išdėstyti bet kokia tvarka. Svarbu įsidėmėti, kad eilutės nėra skaičiai, nors ir susideda vien tik iš skaitmenų. Atskirti eilutę nuo skaičiaus yra labai paprasta – eilutė yra apgaubta kabutėmis. Pavyzdžiui, kintamasis skaičius yra eilutės tipo (skaičius = “666”), nes jo reikšmė “666” yra tarp kabučių. Jei pridėsime “666” prie “666”, tai gausime “666666”, o ne “1332”. Aritmetinių veiksmų su eilutės tipo duomenimis atlikti negalima.
Dažniausiai eilutes tenka sujungti. Tai daryti reikia ženklo “+” pagalba:
tekstas = “Laba” + “ “ + “diena”;
Egzistuoja ir specialus metodas ActionSript, tarnaujantis eilučių sujungimui. Tai metodas concat:
a = ‘Laba’;
tekstas = a.concat( ” “,”diena”);
Taip pat kelias eilutes galima sujungti ir operatoriaus add pagalba:
tekstas = “Laba” add “ “ add “diena”;
Tam, kad sujungti tam tikrą eilutę su skaičiumi, nėra būtina skaičių pateikti kaip eilutę. Skaičius, jungiamas su eilute, yra suprantamas kaip eilutės tipo. Pavyzdžiui, sekančios eilutės pateikia identišką rezultatą (“Su naujais, 2004 metais”):
tekstas = ( “Su naujais, “+ “2004” + ” metais”);
tekstas = ( “Su naujais, “+ 2004 + ” metais”);
Tačiau kartais skaičių pateikimas eilučių pavidale yra efektingesnis, pavyzdžiui, kai norima atvaizduoti reikšmę su mažareikšmiais nuliais (jų kiekis parodo tikslumo lygį):
tekstas = “Reikšmė = “ + 325.000;    // Išveda “Reikšmė = 325”
tekstas = “Reikšmė = “ + “325.000”;    // Išveda “Reikšmė = 325.000”
Eilutes galima lyginti. Eilutės lyginamos tikrinant ar sutampa visi eilutės simboliai operatoriaus “==” pagalba. Toliau pateikiamas scenarijaus kūrimo mygtukui pavyzdys, kuris lygina dvi įvestas eilutes (a kintamojo ir b kintamojo) bei pateikia rezultatą (kintamojo x lauke “Sutampa” arba “Nesutampa”). Tekstinio lauko naudojimas darbalaukyje yra geras būdas mokymui dirbti su kintamaisiais, nes yra matoma kokia yra kintamojo reikšmė.
1.    Pasirinkite Window→CommonLibraries→Buttons (Langas→Pagrindinės bibliotekos→ Mygtukai) meniu komandą ir iškelkite pasirinktą mygtuką ant scenos. Tada parinkite įrankių juostoje teksto rašymo mygtuką (Text Tool          ) ir nupiešę tris teksto rėmelius parašykite komentarus: Rezultatas x; Reikšmė a; Reikšmė b.
2.    Tuo pačiu teksto rašymo mygtuku nubrėžkite tris tuščius teksto rėmelius. Ant kiekvieno jų paspauskite dešinį pelės klavišą ir parinkite komandą Panels → Text Options (teksto savybių dialogo langą galite išsikviesti ir meniu komanda Text → Options). Parinkite teksto tipą Input text (įvedamas tekstas), o langelyje Variable (kintamasis) įrašykite kintamojo vardą, tai yra kiekvienam teksto rėmeliui priskirkite atitinkamai vardus a; b; x.
3.    Pažymėkite mygtuką ir pasirinkite Window→Actions (Langas→Veiksmai), kad atvertumėte Actions (veiksmai) dialogo langą.
4.    Object Actions (veiksmai su objektais) dialogo lange pelyte paspauskite Actions katalogą ir jį atverkite.
5.    Dukart pelyte paspauskite if (jeigu) veiksmą. Taip jį įtrauksite į kuriamą scenarijų.
6.    Langelyje Condition (sąlyga) įveskite a == b. Lyginimo operatorių (==) galite įvesti klaviatūra arba parinkti iš Operators katalogo.
7.    Dabar turime priskirti kintamajam x (Rezultatui) reikšmę “Sutampa”. Tai galima padaryti aprašant kintamąjį x. Iš katalogo Actions parinkite veiksmą set variable (aprašyti kintamąjį) ir langelyje Variable (kintamasis) įveskite kintamojo vardą x, o langelyje Value įveskite kintamojo x reikšmę “Sutampa”.
8.    Priešingu atveju, jei kintamųjų a ir b reikšmės nesutampa, rezultatas turi būti “Nesutampa”. Kataloge Actions parinkite veiksmą else ir pakartokite visus veiksmus, aprašytus 7 punkte (vietoje reikšmės “Sutampa” įveskite reikšmę “Nesutampa”).
Kodas turi atrodyti taip:
on (release) {
if (a == b) {
x = “Sutampa”;
} else {
x = “Nesutampa”;
}
}
Parinkite komandą Control→Test Movie ir, įvedę į kintamųjų a ir b laukelius eilutes, paspauskite mygtuką, kad pamatytumėte rezultatą. Jei eilutės, įvestos į teksto laukelius a ir b yra vienodos, tai rezultato teksto laukelyje x bus rašoma “Sutampa”, tačiau, jei skirsis bent vienas eilutės simbolis (programa skiria ir didžiąsias/mažąsias raides), bus rašoma “Nesutampa”. Ekrane turite matyti panašų rezultatą:

Lyginti eilutės ilgį, naudojant loginius operatorius, yra neįmanoma. Lyginimo operatoriai gali būti pavartoti tik atitinkamų dviejų simbolių pozicijų abėcėlėje sugretinimui. Pavyzdžiui:
trace (“A” < “B”) pateiks rezultatą true, nes raidė A abėcėlėje stovi ankščiau nei B.
Norint sužinoti eilutės ilgį, reikia kreiptis į savybę length, kuri priklauso klasei String:
a = “Labas”;
x = a.length;
X kintamojo reikšmė bus lygi 5, tai yra kintamojo a eilutės ilgis. Dirbant su eilutėmis, reikia nepamiršti, kad tarpai bei skyrybos ženklai taip pat yra simboliai.
Iš eilučių galima iškirpti poeilutes. Tai galima realizuoti dviem klasės String metodais:
•    substring metodas išskiria iš simbolių sekos eilutę, kurios pirmas simbolis turi indeksą indexA + 1, o paskutinis – indexB (jei paskutinis eilutės simbolis neapibrėžtas, tai sistema automatiškai priskiria jį eilutės ilgiui, t.y. išskiriama simbolių eilutė nuo pradinio nurodyto simbolio indekso iki eilutės galo). Reikia nepamiršti, kad eilutės simbolių indeksai pradedami skaičiuoti nuo vieneto. Pavyzdžiui:
x = “Laba diena”;
a = x.substring( 5, 10 )
A kintamojo reikšmė bus “diena”.
•    substr  metodas išskiria iš simbolių sekos length ilgio eilutę, kurios pirmas simbolis turi indeksą start + 1 (jei išskiriamos eilutės ilgis nenurodomas, tai sistema išskiria eilutę nuo nurodyto simbolio iki eilutės galo). Pavyzdžiui:
x = “Laba diena”;
a = x.substr ( 5, 5 )
A kintamojo reikšmė bus “diena”.
Simbolių eilutėms apdoroti Flash 5 ActionScript yra pateikta keturiolika klasės string metodų. Lentelėje pateikiami dar nepaminėti klasės string metodai:
Metodas    Aprašymas    Pavyzdys
Rezultatas
.charAt( index )    Iš eilutės išskiriamas simbolis, kurio indeksas yra index + 1    x = “Laba diena”;
a = x.charAt( 9 )    “a”
.charCodeAt( index )    Išvedamas eilutės simbolio, kurio indeksas yra index + 1, kodas    x = “Laba diena”;
a = x.charCodeAt(1)    97
String.fromCharCode( num1, …, numN )    Išvedamas nurodyto kodo simbolis    a = String.fromCharCode(97)    a
.indexOf(searchString, fromIndex )    Išvedamas nurodyto simbolio indeksas (eilės numeris eilutėje skaičiuojant nuo nulinio), ieškoma nuo nurodyto indekso. Jei nurodytas simbolis yra ne vienas, tai išvedamas pirmojo simbolio indeksas. Jei ieškomo simbolio nėra, išvedama –1.    x = “Laba diena”;
a = x.indexOf( “a”, 0 )    1
.lastIndexOf(searchString, fromIndex )    Išvedamas paskutinio nurodyto simbolio indeksas (eilės numeris eilutėje skaičiuojant nuo nulinio), ieškoma iki nurodyto indekso. Jei ieškomo simbolio nėra, išvedama –1.    x = “Laba diena”;
a = x.lastIndexOf(“a”,9)    9
.split( separator )    Iš simbolių eilutės išmetamas nurodytas simbolis ir į jo vietą įrašomas kablelis.    x = “Laba diena”;
a = x.split( “a” )    L,b, dien,
.toLowerCase()    Simboliai pervedami į mažąsias raides.    x = “Laba diena”;
a = x.toLowerCase()    laba diena
.toUpperCase()    Simboliai pervedami į didžiąsias raides.    x = “Laba diena”;
a = x.toUpperCase()    LABA DIENA

Loginės išraiškos:
Object Pascal kalboje loginiams duomenims atvaizduoti vartojamos dvi loginės reikšmės – True ir False. Lyginimo ir loginių reiškinių rezultatas yra loginė reikšmė True (tiesa, 1) arba False (netiesa, 0). Loginiai kintamieji aprašomi tipu boolean. Loginiams kintamiesiems galioja lyginimo ir loginės operacijos (or, and, not) (Programavimas Delphi, 57).
ActionScript kalboje loginės išraiškos taip pat gali įgyti dvi reikšmes: teisinga (true) arba klaidinga (false). ActionScript taip pat konvertuoja reikšmes true ir false atitinkamai į 1 ir 0. Pavyzdžiui, jei teigsime, kad 10 daugiau už 15, tai bus neteisinga, o jei atvirkščiai, kad 15 daugiau už 10, tai tokia išraiška bus teisinga. Sekanti išraiška grąžina reikšmę false: daugiau = 10 > 15. Loginę išraišką galima vartoti ir kaip dalį matematinės išraiškos. Kadangi true lygu 1, o false lygu 0, tai scenarijus
daugiau = 5 > 4;
rez = daugiau + 19;
kintamajam rez priskirs reikšmę lygią 20. Loginių išraiškų reikšmes galima skirtingai interpretuoti. Jei loginę išraišką patalpinsime į tekstinį lauką, tai jos reikšmė bus interpretuojama kaip true ar false, o jei kintamąjį, asocijuojamą su tokiu tekstiniu lauku, naudosime matematinėje išraiškoje, tai ActionScript kalba nagrinės jį kaip 1 arba 0.
ActionScript sakiniuose loginės reikšmės dažniausiai naudojamos su loginiais operatoriais: < (mažiau), < = (mažiau arba lygu), > (daugiau), > = (daugiau arba lygu), = = (lygu), <> arba != (nelygu), not arba ! (loginis neigimas), or arba || (loginė sudėtis), and arba && (loginė daugyba).

3. PAGRINDINĖS VALDYMO STRUKTŪROS
3.1 NUOSEKLI VEIKSMŲ SEKA

Dažnai veiksmai algoritmuose atliekami nuosekliai vienas po kito. Kompiliatorius vykdo visus scenarijuje užrašytus sakinius iš eilės. Toks scenarijus yra vadinamas tiesiniu. Kompiuteris atlieka scenarijuje užrašytus veiksmus su kintamųjų reikšmėmis bei konstantomis, o gautuosius rezultatus priskiria kintamiesiems. Kintamųjų reikšmės yra pakeičiamos, tai yra priskiriamos naujos, jei šie kintamieji jau turi ankščiau įgytas reikšmes. Taip tęsiama tol, kol gaunami galutiniai rezultatai.
Mokant moksleivius reikšmių priskyrimo bei nuoseklios veiksmų sekos, reikia akcentuoti, kad senos kintamųjų reikšmės yra užmirštamos ir jos yra pakeičiamos naujomis. ActionScript scenarijus  leidžia tai vaizdžiai pateikti. Taip pat reikia akcentuoti, kad priskyrimo operatorius ActionScript kalboje yra lygybės ženklas (=), o Object Pascal – dvitaškis ir lygybė (:=). Sekančiame pavyzdyje demonstruojama kaip keičiasi tų pačių kintamųjų reikšmės, vykdant tiesinį scenarijų. Norint parodyti, kad veiksmai yra atliekami nuosekliai vienas po kito, galima pasinaudoti keliomis mygtuko savybėmis (on (rollOver) – kai pelės žymeklis yra virš mygtuko, on (press) – kai mygtukas yra nuspaudžiamas, on (release) – kai mygtukas yra atleidžiamas, on (roolOut) – kai pelės žymeklis yra patraukiamas nuo mygtuko). Tokiu būdu kintamiesiems reikšmės bus priskiriamos ne visiems kartu, o palaipsniui, demonstruojant veiksmų nuoseklumą ir kintamųjų reikšmių keitimąsi. Scenarijus rašomas vienam mygtukui.
on (rollOver) {
x = 500;
}
on (press) {
a = 8;
}
on (release) {
b = 7;
}
on (rollOut) {
x = (a + b)/2;
}
Parinkite komandą Control→Test Movie ir pamažu spauskite mygtuką, kad pamatytumėte rezultatą. Kai pelės žymeklis atsiduria virš mygtuko, kintamajam x priskiriama reikšmė 500; nuspaudus mygtuką, kintamojo a reikšmė tampa lygia 8; atleidus mygtuką, kintamojo b laukelyje įrašoma reikšmė 7; patraukus pelės žymeklį nuo mygtuko, kintamojo x reikšmė yra perskaičiuojama ir pakeičiama (sena reikšmė pamirštama ir į kintamojo x lauką įrašoma nauja reikšmė 7.5). Ekrane turite matyti panašų rezultatą:
Nuoseklią veiksmų seką galima moksleiviams pademonstruoti ir nenaudojant skriptų kalbos. Tai galima padaryti pasitelkiant į pagalbą kadrus. Kiekviename kadre galima nupiešti po skirtingą piešinį ir testuojant filmą pabrėžti, kad kadrai yra vykdomi vienas paskui kitą nuosekliai. Keičiantis kadrams, keičiasi ir piešiniai. Tačiau čia reikia nepamiršti įvertinti kadrų vykdymo trukmės. Jei skirtingus piešinius patalpinsime į atskirus vienetinius kadrus, tai mūsų akis nespės užfiksuoti piešinių keitimosi. Tam reikia skirtingus piešinius talpinti kelių kadrų intervalais. Tai galima padaryti sekančiu būdu:
1.    Pirmame kadre įterpkite paveikslėlį meniu komandą File → Import (įterpti failą).
2.    Klavišu F5 arba meniu komanda Insert → Frame (įterpti kadrą) įterpkite kelis tarpinius kadrus, kad būtų galima pastebėti kaip keičiasi piešiniai.
3.    Klavišu F6 arba komanda Insert → Keyframe (įterpti raktinį kadrą) įterpkite naują kadrą, kuriame seną paveikslėlį ištrinkite ir įterpkite naują.
4.    Įterpkite kelis tarpinius kadrus (F5).
5.    Tuos pačius veiksmus kartokite tiek kartų, kiek norite įterpti naujų paveikslėlių.
Vaizdas ekrane turi atrodyti taip:
Čia matomas tik paskutiniame raktiniame kadre įterptas paveikslėlis.

Uždavinys:  Parašykite scenarijų, kuris apskaičiuotų kintamojo a reikšmę pagal formulę: a =  (b2 + c) / 2. Kintamasis b apskaičiuojamas prie įvesto skaitmens b pridėjus atsitiktinai sugeneruotą reikšmę iš intervalo nuo 0 iki 100. Kintamieji b ir c įvedami klaviatūra.
Šiai užduočiai įvykdyti, reikės trijų tekstinių laukų, kurių tipas bus Dynamic Text ir jų kintamųjų vardai atitinkamai a, b ir c. Komentarams virš tekstinių laukų naudosime paprastą (Static Text) tekstinį lauką. Taip pat bus reikalingas mygtukas, kuriam rašysime scenarijų. Mygtukui reikia parašyti tokį scenarijų:
on (release) {
b = new Number(b);
c = new Number(c);
b = b + random (100);
a = (b*b + c) / 2;
}
Pirmiausia priskyrimo sakiniais nustatomi tekstinių laukų kintamųjų a ir b tipai. Reikia apibrėžti, kad tai yra skaitinės reikšmės, nes kitaip programa supras įvestus simbolius kaip eilutės tipo. Toliau apskaičiuojama kintamojo b reikšmė, prie įvestos klaviatūra reikšmės pridedant atsitiktinai sugeneruotą skaičių (0..100). Tai leidžia padaryti funkcija random, kurios skliausteliuose reikia nurodyti skaičių intervalo galutinę ribą. Apskaičiuojama kintamojo a reikšmė pagal nurodytą formulę. Visi veiksmai scenarijuje atliekami vienas paskui kitą. Negalima apskaičiuoti kintamojo a reikšmės, prieš tai neapskaičiavus kintamojo b.
3.2 SĄLYGOS OPERATORIAI

Veiksmai algoritmuose atliekami nuosekliai vienas po kito ne visada. Dažnai tenka pasirinkti, kurį veiksmą atlikti. Veiksmų pasirinkimas priklauso nuo tikrinamos sąlygos. Jei sąlyga yra teisinga, atliekami vieni veiksmai,o jei klaidinga – kiti. Sąlyginiu sakiniu keičiama nuosekli sakinių atlikimo tvarka. Kompiuterinė programa gali turėti tik tris esmines struktūras: nuosekli veiksmų seka nuo vienos išraiškos prie kitos, sąlygos operatorius ir ciklas. Visos programavimo kalbos ir scenarijai naudoja panašias struktūras, kuriose vyksta lyginimas ir yra vykdomas alternatyvus veiksmas, priklausomai nuo rezultato. Ne išimtis ir ActionSript.
Algoritmavime (programavime) vieno veiksmo iš keleto pasirinkimas išreiškiamas sąlyginiu sakiniu (V. Dagienė “Informacinės technologijos 2 dalis”, p. 205). Paskalio kalba vieno veiksmo parinkimas užrašomas taip:
if sąlyga (loginis reiškinys)
then sakinys
else sakinys
If reiškia “jeigu”, then reiškia “tuomet”,else reiškia “priešingu atveju”. Jei sąlyga tenkinama, tai atliekamas sakinys einantis po žodžio then, jeigu sąlyga netenkinama – sakinys einantis po žodžio else.
Galimas ir sutrumpintas sąlyginis sakinys, turintis tik vieną šaką (then), kuri atliekama tik tuomet, kai sąlyga yra tenkinama:
if sąlyga
then sakinys
Sąlygos išraiškos Actionscript kalboje turi tris esminius pavidalus: IF…, IF…ELSE, IF…ELSE IF. Kiekvienas variantas tarnauja nustatytam tikslui ir gali būti naudojamas įvairiose situacijose.
IF…
Struktūros IF… pagalba scenarijus tikrina sąlygą, o paskui vykdo ar nevykdo nurodytą veiksmų seką. Jei sąlyga yra tenkinama, tai nurodyta veiksmų seka yra vykdoma, priešingu atveju – nevykdoma. Ta sutrumpintas sąlyginis sakinys. Scenarijus, naudojantis IF… konstrukciją, gali atrodyti taip:
on (release) {
if (a==’LABAS’) {
x = “VISO”;
}
}
Šiame pavyzdyje, jei kintamojo a reikšmė yra ‘LABAS’, tai yra į kintamojo a tekstinį laukelį įvedamas žodis ‘LABAS’, yra vykdoma komanda figūriniuose skliaustuose – kintamajam x priskiriama reikšmė ‘VISO’. Jei bus įvesta kita kintamojo a reikšmė, o ne žodis ‘LABAS’, šiuo atveju nieko neatsitiks ir kintamojo x laukelis liks tuščias. Jei norima aprašyti veiksmą priešingu atveju, reikia pridėti komandą ELSE.
Lyginant su sąlyginiu sakiniu Paskalio kalboje, ActionScript nenaudoja žodelio then. Sakiniai, kurie turi būti vykdomi, jei sąlyga yra tenkinama, yra apjungiami figūriniais skliausteliais. Kaip ir daugelis objektinio programavimo kalbų, Flash 5 ActionScript naudoja figūrinius skliaustelius ({}) komandų rinkinio aprašymui, kurios turi būti vykdomos, jei sąlyga yra tenkinama. Flash 4 versijoje vietoje figūrinių skliaustelių buvo vartojama komanda EndIf (sąlygos užbaigimas).
IF…ELSE
Komandos IF papildymui galima naudoti komandą ELSE, kuri yra kataloge Actions. Komanda else tampa prieinama, jei jau yra panaudotas operatorius if. Tada dvigubu pelytės spragtelėjimu ją galima įterpti į scenarijų. Normaliame rėžime komandą else galima įdėti tik figūrinių skliaustelių viduje, kurie seka po if. Naudojant struktūrą IF…ELSE galima nurodyti vykdyti vieną iš dviejų alternatyvų. Pavyzdžiui, scenarijus gali būti vykdomas taip: jei kintamasis a yra mažesnis už b (if), tai į kintamojo x laukelį įrašoma reikšmė ‘Mažiau’, priešingu atveju, jei kintamasis a yra didesnis už kintamąjį b (else), tai į kintamojo x laukelį įrašoma reikšmė ‘Daugiau’. Šis scenarijus gali būti užrašomas taip:
on (release) {
if (a<b) {
x = “Mažiau”;
} else {
x = “Daugiau”;
}
}
Jei sąlygos (a<b) reikšmė yra teisinga (true), kintamojo x reikšmė nustatoma trečioje eilutėje. Jei sąlyga grąžina reikšmę klaidinga (false), pirmasis kodo blokas yra praleidžiamas ir vykdomas sakinys po žodžio else. Duotasis scenarijus pateikia veiksmus dvejomis skirtingomis sąlygomis – kai kintamasis a yra mažesnis už kintamąjį b ir kai jis didesnis už kintamąjį b. Jei reikia tikrinti dar kokios nors sąlygos vykdymą, galima pasinaudoti konstrukcija IF…ELSE IF.

IF…ELSE IF
Jei pirmoji sąlyga netenkinama, tai galima pasinaudoti dar viena sąlygos tikrinimo konstrukcija: ELSE IF. Įsivaizduokime sekantį tvirtinimą: “Jei tau yra 18 metų, tai tave įleis į šį filmą, bet jei tau dar nėra 18 metų, o kitame kino teatre rodo filmą vaikams, tai tu turi eiti žiūrėti kito filmo”. Pirmoji sąlyga užduoda antrąją sąlygą. Jeigu (if) tau dar nėra 18 metų, tada, jeigu (else if) kitame kino teatre rodomas filmas vaikams, tai tu turi eiti į kitą kino teatrą.
Šią konstrukciją galima pritaikyti ir sekančiam pavyzdžiui. Sukuriami du vartotojai, kuriems parodomi atitinkami paveikslėliai, priklausomai nuo vartotojo vardo. Vartotojo yra paprašoma įvesti prisijungimo vardą, jei įvestas vardas yra teisingas, tai vartotojui parodomas vienas paveikslėlis, tačiau jei prisijungimo vardas nėra teisingas, vartotojui suteikiama alternatyva ir jo prašoma įvesti kitą prisijungimo vardą, kurio teisingumas iškviečia kadrą su kitokiu paveikslėliu. Scenarijus gali atrodyti taip:
on (release) {
if (a == ‘Jonas’) {
gotoAndStop (2);
} else if (a == ‘Petras’) {
gotoAndStop (3);
}
}

Scenarijus yra sudarytas iš trijų raktinių kadrų (Keyframe). Pirmame kadre yra teksto įvedimo laukelis ir mygtukas, kuriam rašomas scenarijus. Antrame ir trečiame kadruose yra įkeliami skirtingi paveikslėliai. Jei prie programos jungiasi ‘Jonas’, tai jis išvysta vieną paveikslėlį, o jei ‘Petras’ – kitą. Reikia nepamiršti pirmame kadre įterpti veiksmą (Action) Stop () (sustabdyti kadrą), nes priešingu atveju, paleidus filmo vykdymą, visi trys kadrai kartosis nesustodami.
Pasirinkimas vienas iš keleto veiksmų:
Dažnai tenka rinktis vieną (daugiau negu iš dviejų) iš keleto veiksmų. Tuomet pasirinkimą reikia suskaidyti į keletą paprastesnių – kai tenka rinktis vieną iš dviejų veiksmų ir kiekvieną pasirinkimą aprašyti sąlyginiais sakiniais. Toliau pateikiamas elementarus didžiausio skaičiaus iš trijų skaičių radimo pavyzdys. Pavyzdžiui, reikia parašyti, kuris skaitmuo iš trijų įvestų yra didžiausias: 5, 12 ar 7. Jei skaičius 5 yra didesnis už 12, bet yra žinoma, kad skaičius 12 yra didesnis už 5, tuomet skaičių 12 lyginame su 7, ir tą kuris didžiausias priskiriame didžiausiam,tai yra 12. Scenarijus gali atrodyti taip, kai pradiniai duomenys – trys skaičiai a, b, ir c, įvedami vartotojo klaviatūra:
on (release) {
a = new Number(a);
b = new Number(b);
c = new Number(c);
if (a>b) {
if (a>c) {
max = a;
}
} else if (b>c) {
max = b;
} else {
max = c;
}
}
Flash 5 ActionSript kalboje, ieškant didžiausio ar mažiausio skaičiaus iš dviejų, galima pasinaudoti specialiomis matematinėmis funkcijomis:
max = Math.max ( a, b)
min = Math.min ( a, b)

3.3 CIKLAS

Tą patį veiksmą dažnai tenka kartoti daug kartų. Norint išvengti scenarijaus fragmento, kuris kartojasi keletą kartų, kopijavimo, reikia naudoti ciklus. Sudarant algoritmus, kartojimo veiksmai išreiškiami ciklu. Ciklai – vieni iš raktinių bet kokios programavimo kalbos elementų. Ciklai skirti daugkartiniam tam tikros grupės veiksmų vykdymui. Ciklai veiksmą kartoja nustatytą skaičių kartų arba iki tol, kol sutinkama nustatyta sąlyga. Paskalyje dažniausiai vartojami dviejų rūšių ciklai: while ir for. Flash 5 ActionScript turi keturis skirtingus ciklinių veiksmų tipus: while, do…while, for, for…in.
While:
Tai paprasčiausias ciklas. Jo sintaksė labai panaši į Paskalio kalbos ciklo while sintaksę.
while (sąlyga) {
veiksmai}
Šiame cikle vietoje Paskalio kalbos konstrukcijoje vartojamo žodelio do naudojami figūriniai skliausteliai, tarp kurių rašomi veiksmai, kurie turi būti kartojami tol, kol tenkinama ciklo sąlyga. Cikle while, kai nėra išpildoma sąlyga, kuri užrašyta ciklo pradžioje tarp paprastų skliaustelių, ciklas nutraukiamas. Veiksmai, esantys ciklo viduje, paprastai turi skaitliuko didinimo ar mažinimo operatorius. Štai nedidelis pavyzdys:
on (release) {
a = new Number(a);
b = new Number(b);
i = 0;
while (i<a) {
b = b+1;
x = b;
i++;
}
}
Vartotojas klaviatūra įveda du skaičius: a, kuris bus lyginamas su ciklo iteratoriumi i ir b, prie kurio bus pridedamas vienetas tiek kartų, kiek kartų bus atliekamas ciklas. Rezultatas priskiriamas kintamajam x. Norint pabrėžti ciklo veiksmų kartojimo skaičių, siūloma į kintamojo b tekstinį lauką įvesti reikšmę 0, tuomet rezultatas kintamojo x bus toks, kiek kartų atliekamas ciklas.
Labai svarbu teisingai užduoti sąlygos keitimą, nes, pavyzdžiui, užmiršus duotame pavyzdyje užrašyti iteratoriaus i keitimą (didinimą vienetu – i++), ciklas taps begaliniu.
Jei sąlyga ciklo while antraštėje būtų neįvykdoma, pavyzdžiui, jei į kintamojo a laukelį įvesime reikšmę 0, sakiniai ciklo viduje bus praleidžiami ir ciklas nebus vykdomas. Ciklas while yra vykdomas tik vieną kartą, kai pradinė iteratoriaus i reikšmė yra lygi galinei reikšmei (a).
Do…While:
Kartais ciklo darbas būna susijęs su jo turiniu, todėl būtina, kad veiksmų blokas būtų perskaitytas bent vieną kartą. Tokiais atvejais reikia vartoti ciklą do…while. Jo sintaksė:
do {
veiksmai
} while (sąlyga)
Ciklas do…while veikia taip pat kaip ir ciklas while, išskyrus tai, kad sąlyga rašoma ir tikrinama ciklo pabaigoje. Veiksmai ciklo bloko viduje vykdomi pirmiausia, ir tik po to tikrinama sąlyga. Jei ji netenkinama, tai ciklas nutraukiamas, apsiribojant viena iteracija. Šis ciklas visuomet bus vykdomas bent vieną kartą. Pavyzdžiui, jei kintamajam a priskirsime reikšmę 0 arba 1, ciklas vis tiek bus vykdomas vieną kartą ir x kintamojo reikšmė bus lygi b + 1:
on (release) {
a = new Number(a);
b = new Number(b);
i = 0;
do {
b = b+1;
x = b;
i++;
} while (i<a);
}
Pirmiausia atliekami sakiniai, esantys po žodelio do. Toliau tikrinama sąlyga. Jeigu ji netenkinama, tai prie ciklo viduje esančių veiksmų nebegrįžtama. Jeigu sąlyga tenkinama, tai vėl grįžtama prie ciklo sakinių. Veiksmai kartojami tol, kol tenkinama sąlyga. Kai sąlyga netenkinama, ciklas baigiamas.
Ciklai while ir do…while dar vadinami nežinomo kartojimų skaičiaus ciklais, nes iš anksto nėra žinomas kartotinų veiksmų skaičius. Veiksmų kartojimo skaičius priklauso nuo ciklo užduotos sąlygos ir iteratorius keitimo.

3.3.1 ŽINOMO KARTOJIMŲ SKAIČIAUS CIKLAS

Dažnai yra nagrinėjami ciklai, kuriuose į sąlygą įeinančio kintamojo reikšmė keičiama vienodai – didinant ją vienetu. Sąlyga tikrinama tol, kol šio kintamojo reikšmė neviršija tam tikros iš anksto žinomos reikšmės. Ciklas, kai iš anksto žinomas ciklo veiksmų atlikimo skaičius, vadinamas žinomo kartojimų skaičiaus ciklu (V. Dagienė “Informacinės technologijos 2 dalis”, p. 225). Šį ciklą dar vadiname iki ciklu arba for. Paskalio kalboje ciklo for sintaksė yra tokia:
for ciklo kintamasis : = pradinė reikšmė to galutinė reikšmė do
sakinys;
Ciklo antraštė prasideda žodžiu for (tegu). Po jo rašomas kintamojo vardas. Šis kintamasis vadinamas ciklo kintamuoju. Toliau nurodoma, su kuriomis šio kintamojo reikšmėmis, turi būti atliekamas ciklas, tai yra užrašoma pradinė ir galutinė ciklo reikšmės.
ActionScript kalboje žinomo kartojimų skaičiaus ciklas užrašomas taip:
for (pradinis žingsnis; sąlyga; modifikacija) {
sakinys;
}
Naudojant ciklą for, vienoje eilutėje nurodoma pradinė reikšmė, ciklo užbaigimo sąlyga ir keitimosi indeksas. Pavyzdžiui:
on (release) {
for (i=0; i<= 10; i++) {
x = i;
}
}
Čia pradinė reikšmė yra i = 0, ciklo užbaigimo sąlyga – i < = 10, o ciklo keitimosi indeksas – i++. Kintamojo x galutinė reikšmė bus lygi 10. Kintamajam x ciklo iteratoriaus i reikšmė priskiriama 11 kartų, nes ciklas atliekamas 11 kartų (kintamasis i didinamas vienetu nuo 0 iki 10). Sąlyga yra tikrinama prieš kiekvieną kartojimą. Ciklas nutraukiamas, kada sąlyga tampa neteisinga (false). Ciklas atliekamas tik vieną kartą, jei pradinė reikšmė sutampa su galine ir ciklas neatliekamas nei vieno karto, jei ciklo iteratoriaus i pradinė reikšmė yra didesnė už galinę.
Šis pavyzdys Paskalio kalba būtų užrašytas taip:
for i : = 0 to 10 do
x : = i;
Skirtingai nei Paskalio kalboje, ActionSript kalboje žinomo kartojimų skaičiaus cikle for galima aprašyti kintamąjį ir parašyti sakinį, kuris didintų arba mažintų ciklo iteratorių kiekvieną kartą kai yra vykdomas ciklas. Paskalio kalboje cikle for ciklo iteratorius yra visada didinamas vienetu, todėl ir nereikia nurodyti iteratoriaus keitimosi žingsnio. ActionSript kalboje ciklo for iteratorių galima ne tik didinti, bet ir mažinti ir nebūtinai vienetu. Pavyzdžiui, sekantis scenarijus taip pat yra teisingas:
on (release) {
for (i=10; i>0; i=i-2) {
x = i;
}
}
Ciklas atliekamas 5 kartus. Ciklo pradinis žingsnis yra 10 ir kiekvieną kartą mažinamas 2 tol, kol ciklo iteratorius i yra didesnis už 0. Kai ciklo iteratorius i tampa lygus 0, ciklas yra nutraukiamas.
Ciklas for yra toks pat kaip ir ciklas while, tik su supaprastinta sintakse. Modifikacija cikle for ActionSript kalboje gali būti bet koks reiškinys. Šio ciklo antraštėje sakiniai yra atskiriami kabliataškiais, o ne kableliais.
ActionSript kalboje taip pat dar vartojamas ciklas for…in. Šis ciklo tipas naudojamas tik objektų savybėms išskirti. Naudojant kintamąjį su užduotu vardu (sekančiame pavyzdyje a) laikinajam reikšmių saugojimui, ciklas perrenka visas objekto savybes:
on (release) {
skaicius = {pirmas:1, antras:2, trečias:3};
for (a in skaicius) {
x += (a + ‘=’ + skaicius[a]) + newline;
}
}

Šio pavyzdžio rezultatas, kur kintamasis x susietas su tekstiniu lauku, bus sekantis:
pirmas = 1
antras = 2
trečias = 3

Šis ciklas peržiūri objekto skaicius visas savybes ir išveda jas į tekstinį lauką.

3.3.2 CIKLAS CIKLE

Ciklas gali būti sudėtinis, tai yra savyje turėti kitus ciklus. Tokiu būdu vidinis ciklas pilnai įvykdomas prie kiekvienos išorinio ciklo iteracijos. Toliau pateikiamas pavyzdys, kuriame tekstinis laukas (kintamasis x) užpildomas skaičiais nuo 1 iki 9, didinant vienetu. Funkcijos  newline (nauja eilutė) pagalba, rezultatas ekrane matomas kaip suformuota trimatė matrica:

Norint ekrane matyti tokį rezultatą, mygtukui reikia parašyti sekantį scenarijų:
on (release) {
n = 0;
for (var i = 0; i<3; i++) {
for (var j = 0; j<3; j++) {
n = n + 1;
a += n + ‘ ‘;
}
a += newline;
}
}
Išorinis ciklas (iteratorius i) atliekamas 3 kartus (nuo 0 iki 2), o vidinis ciklas (iteratorius j) atliekamas 9 kartus. Išorinis ciklas suformuoja 3 eilutes, o vidinis ciklas užpildo kintamojo a tekstinį lauką skaičiais.
Ciklo vykdymo laikas ActioScript kalboje yra ribotas 15 sekundžių. Per šį laiko tarpą daugelis ciklų spėja įvykdyti milijonus iteracijų. Jei per šį laiką ciklas nėra užbaigiamas, tai ekrane išvedamas pranešimo langas su pasiūlymu nutraukti ciklo darbą. Jei vartotojas atsisako, tai sistema laukia dar keletą sekundžių ir ciklo iteracijų tęsimo atveju išveda pranešimo langą pakartotinai.
4. DUOMENŲ STRUKTŪROS: MASYVAS

Programavime dažnai prireikia dirbti su dideliu kiekiu vieno tipo objektų, taikant jiems vienodas operacijas. Masyvuose saugomi vienodo tipo duomenų rinkiniai, kuriuose yra svarbi narių išdėstymo tvarka. Masyvo narių išdėstymas aprašomas indeksais, o patys masyvų nariai yra vadinami indeksuotais kintamaisiais. Masyvas – tai sutvarkytas duomenų rinkinys, kurio kiekvienas elementas turi unikalų numerį – indeksą (arba keletą indeksų).
Elemento indeksas gali būti sveikasis skaičius arba sveikojo tipo kintamasis, arba net reiškinys, kurio rezultatas yra sveikasis skaičius. Elementus galima numeruoti ir raidėmis. Tuomet indekso kintamasis turi būti simbolinio tipo (J. Blonskis, V. Bukšnaitis, V. Dagienė, V. Jusas, R. Marcinkevičius “Programavimas Delphi”, p. 105).
Matematinis masyvo analogas yra matrica (stačiakampė lentelė, turinti objektų grupę). Masyvą galima įsivaizduoti ir kaip spintą su stalčiais. Kiekviename stalčiuje gali gulėti bet koks daiktas. Norint paimti tam tikrą daiktą, užtenka pasakyti kuriame stalčiuje jis yra.
Paskalio kalboje masyvas aprašomas nurodant jo elementų tipą ir jo indekso tipą:
array [indekso tipas] of elemento tipas
Pavyzdžiui: masyvas = array [1..50] of integer;
ActionScript kalboje masyvas – tai specialios klasės objektas, todėl sukurti jį galima kreipiantis į konstruktorių new:
masyvas = new Array ();
Jei tiksliai yra žinoma kiek elementų bus saugoma masyve, tai konstruktoriaus new skliausteliuose reikia užduoti atitinkamą skaičių.taip bus sukurtas tuščias reikiamo dydžio masyvas:
masyvas = new Array (10);
Toks užrašas naudojamas retai, nes tokią užduotį (aprašyti masyvą) galima paprasčiau. Užtenka surinkti tik porą laužtinių skliaustelių:
masyvas = [];
Daugelyje programavimo kalbų sukuriant masyvą reikia nurodyti jo dydį. Actionsript kalboje masyvo dydis keičiasi dinamiškai, pridedant masyvo reikšmes. Užpildyti masyvą galima iš karto jį sudarant. Konstruktoriaus new skliausteliuose reikia per kablelį įvesti reikalingus duomenis. Jais gali būti bet kokie objektai: skaičiai, eilutės, funkcijos ir netgi kiti masyvai:
masyvas = new Array (2, Math.random (), [‘Labas’, ‘Viso’]);
masyvas1 = [2, Math.random (), [‘Labas’, ‘Viso’]];
Šie masyvai yra identiški, sudaryti iš trijų elementų, kur pirmas yra skaičius 2, antras – atsitiktinai sugeneruojamas skaičius ir trečias masyvo elementas – kitas masyvas, sudarytas iš dviejų simbolinio tipo elementų: ‘Labas’ ir ‘Viso’.
Norint perskaityti masyvo elemento reikšmę, reikia parašyti masyvo vardą ir įvesti laužtiniuose skliausteliuose dominančio masyvo elemento eilės numerį. Reikia nepamiršti, kad masyvų elementų skaičiavimas ActionSript kalboje yra pradedamas nuo nulio. Tai reiškia, kad pirmo masyvo elemento indeksas bus 0, antro – 1 ir taip toliau. Pavyzdžiui:
masyvas = [2, 4, 8, 16]
a = masyvas [0]; // Rezultatas 2
a = masyvas [3]; // Rezultatas 16
a = masyvas [4]; // Rezultatas bus neapibrėžtas, nes tokio masyvo elemento nėra ir kintamojo a tekstinis laukas bus paliktas tuščias. Kreipiantis į neegzistuojantį masyvo elementą ActionSript gražina sisteminę konstantą undefined (neapibrėžta). Scenarijus nėra nutraukiamas. Daugelyje programavimo kalbų panašioje situacijoje įvyksta programos nutraukimas arba grąžinami duomenys, nepriklausantys masyvui.
Užpildyti masyvą galima ir atskirai formuojant kiekvieną masyvo elementą (tik prieš tai reikia nepamiršti sukurti tuščio masyvo):
masyvas = [];
masyvas [0]= 1;
masyvas [1]= 2;
masyvas [10]= 3;
trace (masyvas);
Rezultatas bus 1, 2, , , , , , , , , 3. Paliekami neužpildyti masyvo narveliai. Priskyrus kokį nors dydį masyvo elementui, kurio indeksas yra didesnis už duotojo masyvo ilgį, masyvas padidėja iki reikiamo dydžio. Neužpildyti masyvo narveliai tokiu atveju saugo reikšmę undefined (neapibrėžta).
Masyvo elementai savo savybėmis yra panašūs į kintamuosius. Norint pakeisti saugomą masyvo narvelio dydį, užtenka padaryti naują priskyrimą:
masyvas = [‘Laba’, ‘diena’];
masyvas [1]= 1;
masyvas [1]= ‘vakara’;
trace (masyvas); // Rezultatas bus ‘Laba vakara’.

Kartais yra būtina žinoti masyvo ilgį. Atitinkamą informaciją saugo klasės Array savybė length:
masyvas = [‘Laba’, ‘diena’];
a = masyvas.length;
Keičiant šios savybės reikšmę, keičiamas ir masyvo ilgis. Elementai su indeksais, išeinančiais už nurodyto dydžio ribų, bus paprasčiausiai pašalinti:
masyvas = [‘Laba’, ‘diena’, ‘saulyte’];
masyvas.length = 2;
a = masyvas[2];
Kintamojo a tekstinio lauko reikšmė bus tuščia, nes paskutinis elementas, kurio indeksas 2, buvo pašalintas iš masyvo, priskiriant masyvo ilgiui reikšmę 2.
Masyvo elementus pašalinti galima keliais būdais. Jei reikia išvalyti masyvo narvelį, nepakeičiant bendro masyvo ilgio, tai galima kreiptis į operatorių delete. Šis operatorius nepašalina masyvo narvelio, o pakeičia jame esantį objektą į sisteminę konstantą undefined (neapibrėžta):
masyvas = [‘Laba’, ‘diena’, ‘saulyte’];
delete masyvas [0];
a = masyvas.length;
trace (masyvas);
Masyvo elementai bus ‘ , diena, saulyte’, o kintamojo a reikšmė (masyvo ilgis) bus lygi 3.
Norint pašalinti paskutinį masyvo elementą, keičiant ir masyvo ilgį, galima kreiptis į metodą pop ():
masyvas = [‘Laba’, ‘diena’, ‘saulyte’];
masyvas.pop();
a = masyvas.length;
trace (masyvas);
Masyvo elementai bus ‘Laba, diena’, o masyvo ilgis – 2.
Analogiškas metodui pop (),tik šalinantis pirmą masyvo elementą, yra metodas shift (). Jį naudojant, visi aukščiau esantys masyvo elementai pasistumia žemyn ir masyvo ilgis sutrumpėja vienetu.
Norint pašalinti bet kurį masyvo elementų, išdėstytų bet kuriose pozicijose, kiekį, naudojamas metodas splice (). Šis metodas yra universalus ir gali būti naudojamas tiek masyvo elementų šalinimui, tiek ir jų pridėjimui į masyvą su masyvo ilgio keitimu. Jo sintaksė:
masyvo vardas.splice (startIndex, deleteCount, item1, item2, …, itemN);
•    startIndex – sveikasis skaičius, nurodantis, nuo kelinto narvelio prasideda masyvo elementų šalinimas ar priskyrimas. Jei daugiau jokie parametrai nėra apibrėžti, tai šalinami visi elementai, pradedant nuo startIndex (įskaitant ir jį);
•    deleteCount – nebūtinas parametras, nurodantis šalinamų elementų kiekį (įskaitant masyvo elementą su indeksu startIndex);
•    item1, item2, …, itemN – nebūtini parametrai, saugantys pridedamų elementų reikšmes, pradedant pozicija startIndex.
masyvas = [1, 2, 3, 4, 5];
masyvas.splice (2, 2, ‘A’, ‘B’);
trace (masyvas);
Šiame pavyzdyje suformuojamas masyvas iš penkių elementų: 1, 2, 3, 4, 5. Antroje scenarijaus eilutėje metodu splice () iš masyvo pašalinami du elementai (deleteCount – 2) pradedant elementu, kurio indeksas yra 2 (startIndex – 2), ir į pašalinamų masyvo elementų vietas įrašomi nauji elementai (item1, item2 – ‘A’, ‘B’). Suformuojamas naujas masyvas: 1, 2, A, B, 5.
Naujus elementus į masyvą galima įterpti ir dar trijų metodų pagalba:
•    push (item1, item2, …, itemN) – prideda elementą (ar grupę elementų) į masyvo galą;
•    unshift (item1, item2, …, itemN) – prideda elementą (ar grupę elementų) į masyvo pradžią;
•    concat (elementList) – sujungia kelis masyvus į vieną masyvą, pridėdamas elementus į masyvo galą. Sukuriamas naujas masyvas. Pavyzdžiui:
masyvas = [1, 2, 3, 4, 5];
masyvas1 = [6, 7];
masyvas2=masyvas.concat (masyvas1);
trace (masyvas2); // Rezultatas masyvas2 bus: 1, 2, 3, 4, 5, 6, 7.
Taip pat ActionScript kalboje yra keletas metodų, palengvinančių masyvų apdorojimą:
•    reverse () – keičia masyvo elementų tvarką atvirkštine:
masyvas = [1, 2, 3, 4, 5];
trace (masyvas.reverse ());    // Rezultatas masyvas bus: 5, 4, 3, 2, 1.
•    sort (orderFunc) – rūšiuoja masyvą vartotojo sukurtos funkcijos pagalba. Jei funkcija nėra nurodyta, masyvas rūšiuojamas abėcėlės tvarka, tiksliau pagal simbolių kodines pozicijas. Norint masyvą rūšiuoti pagal nurodytą taisyklę, reikia sukurti funkciją (kurios vardą reikia įrašyti metodo sort () skliausteliuose), nusakančią, kaip turi būti surūšiuoti bet kurie du elementai. Ši funkcija turi perduoti atitinkamai du parametrus. Rūšiavimo sąlygą funkcijoje reikia nurodyti taip, kad jei pirmas elementas eina ankščiau už antrą, funkcija grąžina –1; jei antras elementas turi būti pirma pirmojo, tai funkcijos reikšmė turi būti +1; jei elementai lygūs, tai funkcija turi grąžinti 0.
Toliau pateiksime scenarijaus pavyzdį, kuris rūšiuoja masyvo elementus – skaičius didėjimo tvarka:
masyvas = [1, -23, 78, 0, 4.89, 0.567, Number.MAX_VALUE, Number.NEGATIVE_INFINITY];
function rusiavimas (sk1, sk2) {
if (sk1<sk2) {
return -1;
}
if (sk1>sk2) {
return 1;
} else {
return 0;
}
}
trace ( masyvas.sort (rusiavimas));
Rezultatas bus: -Infinity, -23, 0, 0.567, 1, 4.89, 78, 1.79769313486231e+308
Tuo tarpu, naudojant rūšiavimo metodą sort () be nurodytos funkcijos, tokio pačio masyvo elementai bus surūšiuoti pagal masyvo elementų simbolių kodines pozicijas:
-23, -Infinity, 0, 0.567, 1.79769313486231e+308, 1, 4.89, 78
Tai nėra skaičiai išdėstyti didėjimo tvarka. Todėl, norint surūšiuoti masyvo elementus didėjimo tvarką, reikia nurodyti funkciją, pagal kurią turi būti rūšiuojami masyvo elementai. Masyvo elementai bus rūšiuojami mažėjimo tvarka, jei ankščiau pateiktoje funkcijoje rusiavimas sukeisime vietomis grąžinamas funkcijos reikšmes –1 ir +1.
Dar liko nepaminėti trys metodai, skirti masyvo elementų apdorojimui ActionSript kalboje. Trumpai juos aptarsime:
•    slice (IndexA, IndexB) – išskiria masyvo elementų grupę, pradedant nuo elemento su indeksu IndexA ir baigiant elementu, kurio indeksas yra IndexB. Skirtingai nei splice (), šis metodas nekeičia nagrinėjamo masyvo.
•    join (separator) – pateikia visus masyvo elementus eilutės pavidale. Čia separator – simbolis, kuris turi atskirti masyvo elementus vieną nuo kito. Šis simbolis turi būti rašomas tarp kabučių.
•    toString () – metodas, kuris išveda masyvo elementų, perverstų į eilutes ir atskirtų kableliais, sąrašą.
5. DUOMENŲ STRUKTŪROS: ĮRAŠAS

Eilutės ir masyvai yra skirti vienodo tipo duomenų rinkiniams saugoti. Sprendžiant daugelį uždavinių, tokių struktūrų nepakanka, nes tenka apdoroti iš įvairių tipų elementų sudarytus duomenų rinkinius. Pavyzdžiui, nagrinėjant moksleivių trimestro rezultatus, tenka apdoroti duomenų rinkinius, kurie apibūdina tiek patį moksleivį bei mokomuosius dalykus, tiek įvairių dalykų pažymius. Moksleivio vardas, pavardė, mokomasis dalykas yra aprašomi žodžiais (simbolių rinkiniais), o pažymius, kurie gali būti vartojami vidurkio skaičiavimui, reikia žymėti skaičiais. Tokio mišraus tipo duomenų rinkiniams registruoti yra skirti iš laukų sudaromi įrašai. Paskalio kalboje įrašų aprašų sintaksė yra:
record
<laukų aprašai>
end
Įrašo laukais gali būti tiek skaičiai, tiek masyvai, eilutės ir kiti įrašai. Pavyzdžiui:
type
trimestras = record
vardas, pavarde, dalykas: string[10];
pazimys: integer
end;
var
sarasas: array[1..30] of trimestras;
mokinys: trimestras;
Kreipiantis į įrašų laukus, yra vartojami sudėtiniai vardai:
<įrašo vardas>.<lauko vardas>
Pavyzdžiui: mokinys.vardas.

6. TEKSTINĖS BYLOS

Kartais būna geriau pradinius duomenis programai paruošti iš anksto ir tada pateikti duomenų rinkinį programai atlikti. Taip galima išvengti klaidų pradiniuose duomenyse. Tokie duomenų rinkiniai vadinami duomenų bylomis. Šiame darbe nagrinėsime tik tekstines bylas.
Object Pascal kalboje, dirbant su tekstinėmis bylomis, turi būti aprašyti bylos kintamieji, kurių tipas nurodomas žodžiu TextFile. Programoje kiekvienas bylos kintamasis turi būti siejamas su konkrečia operacinės sistemos byla. Tai nurodoma standartine procedūra AssignFile (BylosKintamasis, BylosVardas). Norint skaityti iš bylos duomenis, reikia bylą paruošti skaitymui komanda Reset (BylosKintamasis). Duomenys skaitomi, naudojant procedūras Read ir ReadLn. Baigus darbą su bylomis, jas būtina uždaryti standartine procedūra CloseFile (BylosKintamasis). Bylą sudarančių eilučių pabaigai atpažinti bei visos bylos pabaigai nustatyti naudojamos loginės funkcijos Eoln (BylosKintamasis) ir Eof (BylosKintamasis).
ActionScript kalboje taip pat galima nuskaityti tekstines bylas pavyzdžiui, į tekstinį lauką. Tačiau tam tekstinėje byloje reikia priskirti tekstinio lauko kintamajam tuos simbolius, kurie turi būti išvesti į tekstinį Flash lauką. Kad būtų aiškiau, išnagrinėkime pavyzdį:
1. Sukurkite tekstinį lauką įrankiu Text Tool           ir dialogo lange Text Options (teksto savybės), parinkę teksto tipą Dynamic Text,  įveskite kintamojo (Variable) vardą, pavyzdžiui a.
2. Įterpkite į sceną mygtuką.
3. Sukurkite tekstinį failą, kuris bus skaitomas scenarijuje. Tam atsidarykite programą Notepad ir įveskite sekančią eilutę: a=Laba diena, saulyte. Išsaugokite failą pavadinimu tekstas.txt. Čia tekstinio lauko kintamajam a priskyrėme simbolių eilutę, kuris bus išvesta į Flash sceną.
4. Mygtukui parašykite sekantį scenarijų:
on (release) {
loadVariables (“tekstas.txt”, a);
}
Paleidus filmą ir paspaudus mygtuką, ekrane išvysite tokį vaizdą:

Tekstinės bylos nuskaitymą ir priskyrimą Flash tekstinio lauko kintamajam vykdo funkcija loadVariables(). Kintamajam tekstinė eilutė priskiriama jau tekstinėje byloje tekstas.txt. Ši funkcija tik kreipiasi į tekstinę bylą ir perkelia jos sudėtį į Flash scenarijų. Funkcijoje turi būti tarp kabučių nurodytas failo, kuriame aprašyti kintamieji, vardas ir kintamojo, kuriam priskiriama tekstinio failo sudėtis, vardas. Toliau su tekstu galima dirbti kaip su eilutės tipo kintamuoju. Pavyzdžiui, norint sužinoti eilutės ilgį, užtenka parašyti trace(a.length); norint išskirti iš eilutės žodį “Laba”, scenarijuje reikia įvesti eilutę    trace(a.substring(0,4)) ir panašiai.
ActionScript kalboje nereikia aprašyti bylos kintamųjų, paruošti failo skaitymui ar uždaryti failą. Failo turinys tiesiog priskiriamas nurodytam kintamajam. Tačiau reikia nepamiršti, kad priskyrimas turi būti vykdomas (aprašytas) pačiame tekstiniame faile.
Object Pascal kalboje duomenys tekstinėse bylose pateikiami suskirstyti į eilutes ir eilučių pabaigos bei bylos pabaiga žymimos eilučių ir bylos pabaigos simboliais. Tekstinės eilutės skaitomos po vieną simbolį. ActionScript kalboje duomenys yra nuskaitomi kaip viena simbolinio tipo eilutė ir simboliai nėra atskiriami vienas nuo kito. Pavyzdžiui, Object Pascal kalboje, jei tekstinėje byloje yra surašyti skaičiai, atskirti tarpais, tai su jais galima atlikti aritmetinius veiksmus. Tuo tarpu ActionScript kalboje skaičiai bus nuskaityti kaip simbolinio tipo eilutė, įskaitant ir tarpus. Aritmetinių veiksmų su simbolinio tipo kintamaisiais atlikti negalima. Taip pat ActionScript kalboje apdorotų duomenų rašymas atgal į tekstinę bylą nėra leistinas. Objest Pascal kalboje rezultatai surašomi į bylą standartinėmis procedūromis Write (BylosKintamasis) ir Writeln (BylosKintamasis), prieš tai bylą parengus rašymui procedūra Rewrite (BylosKintamasis).
Uždavinys:
Tekstiniame faile yra bet kokių simbolių eilutė. Reikia sudaryti scenarijų, kuris nustatytų, kiek toje eilutėje buvo skaitmenų ir juos visus parodytų ekrane.
Šiai užduočiai įvykdyti, reikės trijų tekstinių laukų, kurių tipas bus Dynamic Text ir jų kintamųjų vardai atitinkamai a, b ir c. Komentarams virš tekstinių laukų naudosime paprastą (Static Text) tekstinį lauką. Taip pat bus reikalingas mygtukas, kuriam rašysime scenarijų. Pirmiausia reikia susikurti tekstinį failą, kuriame kintamajam a priskirkite simbolių eilutę, tarp kurių būtų ir skaitmenų. Mygtukui reikia parašyti tokį scenarijų:
on (release) {
loadVariables (“tekstas.txt”, a);
masyvas = [];
for (i=0; i<a.length; i++) {
masyvas[i] = a.substring(i,i+1);
}
kiek = 0;
for (i =0; i<masyvas.length; i++) {
if ((masyvas[i]>= ‘0’)and (masyvas[i]<= ‘9’)) {
kiek = kiek + 1;
c = c + masyvas[i];
}
}
b = b  + kiek;
}
Pirmiausia yra nuskaitomas tekstinis failas tekstas.txt. Toliau formuojamas masyvas, kurio kiekvienam elementui priskiriamas tekstinio failo simbolis. Peržiūrimas visas masyvas (i<masvas.length) ir masyve esantys simboliai tikrinami, ar tai skaitmuo. Lyginant simbolius jie keičiami jų kodais pagal kodų lentelę. Jei masyve surandamas skaitmuo, tai kintamasis kiek padidinamas vienetu, o į kintamojo c tekstinį lauką išvedamas surastas skaitmuo. Galiausiai kintamajam b priskiriama kintamojo kiek reikšmė. Programos Flash langas turi atrodyti taip (tekstiniame faile parašyta: a=vienas7 89 du ir 3 5):

7. PROCEDŪROS IR FUNKCIJOS

Procedūros:
Object Pascal
Procedūromis yra vadinami kompiuterio valdomų procesų aprašymai, kuriuo programoje galima kreiptis daugelį kartų. Paskalio kalboje procedūrų aprašo sintaksė:
procedure <vardas> (<formalių parametrų aprašai>);
<lokalinių struktūrų aprašai>
<procedūros veiksmai>
Pavyzdžiui: procedure suma (x, y: real; var sum: real);
Parametrai, kurie būna dviejų tipų (parametrai – reikšmės ir parametrai – kintamieji), yra skirti informaciniam ryšiui su programa palaikyti, o lokaliniai aprašai apibūdina procedūros viduje vartojamas struktūras. Procedūrose aprašyti veiksmai yra vykdomi tik tada, kai programoje į jas kreipiamasi sakiniu:
<procedūros vardas> (<faktinių parametrų aprašai>);
Pavyzdžiui: suma (x, y, sum);
Vykdant procedūrą, formalūs parametrai keičiami faktiniais, o keitimo būdas priklauso nuo parametro tipo. Formalūs parametrai – kintamieji, kurie aprašuose pažymimi žodeliu var, procedūroje keičiami kreipimosi sakinyje nurodytais pagrindinės programos kintamaisiais. Taip procedūrai gali būti perduodamos apdorojimui skirtos reikšmės ir grąžinami programai procedūros darbo rezultatai. Parametrais – reikšmėmis, kurių aprašuose žodelis var nenurodomas, duomenys perduodami tik viena kryptimi – iš pagrindinės programos procedūrai ir faktinių parametrų reikšmės nepakinta.
Vartojant procedūras, reikia neužmiršti, kad lokaliniai kintamieji galioja tik procedūrų viduje. Pagrindinėje programoje aprašytos struktūros yra vadinamos globalinėmis. Jos galioja tiek pagrindinėje programoje, tiek ir pagalbinių procedūrų viduje.
ActionScript kalboje tokių scenarijaus dalių kaip procedūros nėra. Tačiau pagal veikimo principą procedūromis galime vadinti ir funkcijas. Vartotojo kuriamos funkcijos ActionScript kalboje yra vykdomos, kaip Object Pascal kalboje procedūros. Plačiau jas apžvelgsime sekančiame skyrelyje.

Funkcijos:
Object Pascal kalboje funkcijos – tai izoliuotos mobiliosios kodo dalys, kurios gali būti iškviečiamos reikiamu momentu ir reikiamą kiekį kartų. Funkcinės savybės yra labai panašios į procedūrų savybes. Nuo procedūrų jos skiriasi kreipimosi būdu ir antraštėmis. Funkcijų vardams yra suteikiamos jų darbo rezultatų reikšmės, todėl šie vardai (kreipiniai į funkcijas) gali būti išraiškų argumentais Funkcijos privalo turėti vieną rezultatą, kuris priskiriamas funkcijos vardui. Funkcijos veiksmuose turi būti bent vienas priskyrimo sakinys, kuriuo funkcijos vardui priskiriama reikšmė. Funkcijų aprašų antraščių sintaksė:
function <vardas> (formalių parametrų sąrašas): funkcijos reikšmės tipas;
funkcijos veiksmai
Funkcijos tekste jos vardą galima rašyti tik kairėje priskyrimo operatoriaus pusėje.
ActionScript kalboje egzistuoja du funkcijų tipai: įterptos į scenarijų kalbą funkcijos (pavyzdžiui funkcija random () sugeneruoja atsitiktinį skaičių) ir vartotojo sukurtos funkcijos. Funkcijų naudojimas scenarijuose pašalina kodo dubliavimo būtinybę. Pavyzdžiui, turint keletą objektų, kuriuos paspaudus turi įvykti vienas ir tas pats veiksmas, nesukūrus funkcijos vieną ir tą patį scenarijų reikės rašyti kelis kartus kiekvienam objektui atskirai. ActionScript kalboje funkcijos aprašomos sekančiu būdu:
function funkcijos vardas (arg1, arg2,…, argN){  //arg1, arg2, …, argN – funkcijos parametrai
scenarijus
}
Skirtingai nei Object Pascal kalboje, ActionScript scenarijuje nereikia nurodyti funkcijos grąžinamos reikšmės tipo. Funkcijos parametrų gali ir nebūti.
Funkcija iškviečiama sistemai skaitant jos vardą. Toliau pateikiamas funkcijos aprašymo ir iškvietimo pavyzdys:
function zodis (zod){
trace (zod);
}
zodis (‘Laba diena’); // testuojant ekrane išvedama ‘Laba diena’.
Kintamieji, aprašomi funkcijos viduje, yra laikomi lokaliais. Labai svarbu yra stebėti, kad nekiltų konflikto tarp funkcijos kintamųjų (lokalinių) ir globalinių kintamųjų. Palyginkime du pavyzdžius:
var n = 0;                 var n = 0;
function vardas () {            function vardas () {
n = 1;                    var n = 1;
}                    }
vardas ();                vardas ();
trace (n); // išveda ‘1’.        trace (n); // išveda ‘0’.
Jei norima pakeisti kintamojo n reikšmę į 1, tai reikia naudoti pirmąją funkciją. Jeigu aprašomas funkcijoje kintamasis neturi veikti kintamųjų, esančių už funkcijos ribų, tai reikia naudoti antrąją funkciją. Vartojant žodelį var, aprašomas naujas kintamasis, kuris pririšamas prie funkcijos. Be žodelio var yra tik kreipiamasi į jau egzistuojantį kintamąjį (naujas kintamasis bus sukuriamas tik tuo atveju, jeigu kintamojo tokiu vardu dar nėra). Tokiu būdu galima paaiškinti kintamųjų vardų galiojimo sritis.
Uždavinys:
Sukurkite scenarijų, kuris susumuotų keturių skaitmenų, esančių masyve sumą ir ją atspausdintų tekstiniame lauke. Skaitmenų sumai skaičiuoti sukurkite funkciją.
Scenarijus, parašytas mygtukui turi atrodyti taip:
on (release) {
sum = 0;
a = ”;
masyvas = [4,5,1,2];
function suma (x) {
sum = sum + x;
}
for (i = 0; i<masyvas.length; i++) {
a = a + masyvas[i];
suma (masyvas[i]);
} b = sum;
}
Pirmiausia aprašomi kintamieji, nurodant jų saugomų reikšmių tipus: sum – skaitinis kintamasis, a – simbolinio tipo kintamasis. Suformuojamas keturių skaičių masyvas. Rašoma funkcija, kuri turi susumuoti perduodamų funkcijai argumentų sumą. Peržiūrimi visi masyvo elementai, kiekvieną jų išvedant į tekstinį lauką a ir perduodant sumavimo funkcijai suma. Sumavimo rezultatas išvedamas į tekstinį lauką b. Masyvo elementų sumos skaičiavimo programos langas:
IŠVADOS

Kompanijai Macromedia pavyko sukurti kalbą, kurią lengva įsisavinti ir panaudoti. ActionScript – tai scenarijų kalba, kuri leidžia maksimaliai išnaudoti Flash programos potencialą. Ji taipogi turi galimybių įgyvendinti visus dizainerių reikalavimus ir turi priemonių interaktyvaus interfeiso kūrimui.
Vyresniojo amžiaus moksleiviams įdomu ir nesudėtinga programuoti Flash SctionScript kalba.
Macromedia Flash ActionScript kalbos galimybių nagrinėjimas, suteikia programavimui žaismingumą. Tačiau užduočių parinkimo pirmas tikslas – formuoti sugebėjimą užduotį išskaidyti į atskiras užduotis, matyti sprendimo visumą, kaip atskirų modulių struktūrą.
Programavimas yra kūrybos procesas, nuolatinė improvizacija, lavinanti mąstymą ir vaizduotę.

LITERATŪRA

1.    Γурский, Д. Α., Горбач, И. В. (2003). Flash MX и ActionScript: обучение на примерах. Минск: Новое знание.
2.    Сандерс, Б. (2002). Эффективная работа Flash 5.  Питер.
3.    Dagienė, V. (2003). Informacinės technologijos IX-X klasėms 2 dalis. Vilnius: TEV.
4.    Blonskis, J., Bukšnaitis, V., Dagienė, V., Jusas, V., Marcinkevičius, R. (2003). Programavimas Delphi išplėstinis modulis XI-XII klasėms. Vilnius: TEV.
5.    Vidžiūnas, V. (1994). Turbo paskalis pavyzdžiais (1 dalis). Kaunas: Litera.