Suomipelit – LUA:n alkeet

Mikä on LUA? #

LUA on tehokas, pienet muistivaatimukset omaava ohjelmointikieli, joka on suunniteltu ohjelmien toiminnallisuuden laajentamiseen. Toisin sanoen LUA on pääasiassa skriptikieli, mutta sillä voi tehdä myös omia itsenäisiä ohjelmia.

LUA on toteutettu pienenä C-funktiokirjastona ja on kirjoitettu ANSI C:llä. Tämän ansiosta se toimii useilla eri käyttöjärjestelmillä, kuten Windows, Windows CE, Linux, BeOs ja niin edelleen. Pienten muistivaatimustensa ansiosta sitä voi käyttää myös sulautetuissa järjestelmissä (esimerkiksi matkapuhelimet).

Aivan kuten Java, myös LUA toimii virtuaalikoneen kautta ja tulkitsee tavukoodia. Yhtenäisyydet loppuvat kuitenkin tähän, koska LUA on pyritty pitämään mahdollisimman yksinkertaisena ja pienet laitteistovaatimukset omaavana kielenä.

Jotta kieleen voisi tutustua mahdollisimman nopeasti, aloitamme artikkelin luomalla oman LUA-tulkin. Pidemmittä puheitta, siirtykäämme ohjelmoimaan!

(Artikkelin esimerkkiohjelmat voit ladata tästä http://www.suomipelit.com/files/artikkel... )

LUA-tulkin luominen #

Ennen kuin voimme aloittaa varsinaisen ohjelmoinnin, meidän tulee luoda projekti joka käyttää LUAa. Tarvitsemme siis joitakin tiedostoja www.lua.org -sivustoilta saatavasta LUA-jakelupaketista. LUAn käyttöönottaminen ei kuitenkaan vaadi koko jakelupaketin hankkimista, tiedostot lua.h, lualib.h, lauxlib.h sekä lua.lib, lualib.lib, lualib_dbg.lib (debuggausta varten) riittävät. Kyseiset tiedostot tulevat ensimmäisen esimerkkiohjelman mukana.

H-päätteiset tiedostot lisätään LUA-funktioita kutsuviin lähdekooditiedostoihin. LIB-päätteiset tiedostot lisätään projektin käyttämiin kirjastotiedostoihin. Visual C++ 6.0:ssa tämä tapahtuu seuraavasti (oletetaan että projekti on jo luotu):

• Mene valikkoon Tools->Options...
  
• Avaa Directories-välilehti
  
• Lisää kohtaan Include Files hakemisto, jossa lua.h-tiedosto sijaitsee
  
• Lisää kohtaan Library Files hakemisto,
  
jossa lua.lib-tiedosto sijaitsee

• Paina OK
  

//---------------------------------------------
// Nimi  : Main.cpp
// Kuvaus: Ensimmäisen LUA-projektin koodi.
//---------------------------------------------
#include <conio.h> //getch()
extern "C"
{
#include <lua.h>
#include <lualib.h>
}



//---------------------------------------------
// Nimi  : main()
// Kuvaus: Ohjelmakoodi
//---------------------------------------------
int main( void )
{
	//
	// Luodaan LUA-virtuaalikone.
	//
	lua_State* pLUAVM = lua_open(0);
	if( pLUAVM == 0 )
		return -1;

	//
	// Otetaan LUAn peruskirjastot käyttöön.
	//
	lua_baselibopen( pLUAVM );

	//
	// Luetaan ja tulkitaan LUA-skripti.
	//
	lua_dofile( pLUAVM, "skripti1.lua" );

	//
	// Lopuksi suljetaan LUA-virtuaalikone.
	//
	lua_close( pLUAVM );

	//
	// Odotetaan napin painallusta ennen poistumista.
	//
	getch();
	return 1;
}

--
-- Ensimmäinen skripti.
-- Kuten huomaat, "--"-merkit tarkoittaa
-- kommenttiriviä.
--
print "Terve maailma!!!"

Ensimmäisen LUA-ohjelman tuloste

Kielen alkeet #

Nyt kun olemme toteuttaneet toimivan LUA-tulkin, voimme perehtyä tarkemmin itse kielen saloihin.


Muuttujat ja niiden tyypit

Muuttujat ovat LUAssa tyypittömiä, mikä tarkoittaa että yksi muuttuja voi sisältää minkä tahansa tyyppisen arvon. Lisäksi muuttujaa ei tarvitse esitellä ennen kuin sille asetetaan arvo. Toisin sanoen koodissa

kirja = "Moby Dick"
kirja = 1
kirja = 0.121

  <  pienempi kuin
  >  suurempi kuin
  <= pienempi tai yhtäsuuri kuin
  >= suurempi tai yhtäsuuri kuin
  == yhtäsuuri kuin
  ~= erisuuri kuin

if <ehto> then
    <koodia>
end

if <ehto> then
    <koodia>
else 
    <koodia>
end

if <ehto> then
    <koodia>
elseif <ehto> then
    <koodia>
else
    <koodia>
end

while <ehto>
do
    <koodia>
end

for <iterointialue>
do
    <koodia>
end

repeat 
    <koodia>
until <ehto>

--
-- Toinen skripti.
-- Kontrollirakenteet.
--


--
-- IF-lause.
--
print "IF-lause"
i = 2
if i == 2 then
    print "i on kaksi"
elseif i == 3 then
    print "i on kolme"
else
    print "i on jotain muuta"
end
print "---------"

--
-- WHILE-silmukka.
--
print "While-silmukka"
i = 0
while i < 10
do
    print(i)
	i = i + 1
end
print "---------"

--
-- WHILE-silmukka, ja poistuminen
-- siitä BREAK-komennolla.
--
print "While-silmukka, poistuminen breakilla"
i = 0;
while i < 10 
do
    print(i)
	if i > 5 then
	    break
    end
	i = i + 1
end
print "---------"


--
-- FOR-silmukka, lasketaan yhdestä kymmeneen.
--
print "FOR-silmukka"
for laskuri = 1,10 do
    print(laskuri)
end
print "---------"


--
-- Repeat-toistosilmukka. 
--
i = 0
repeat 
   print(i)
   i = i + 1
until i == 10

Osa skriptin 2 tulosteesta

Omien C-funktioiden kutsumiseen LUAn kautta #

LUAn tehokkuus kielenä perustuu sen kykyyn kutsua C-funktioita skriptikielen kautta. Tällä tavoin LUAn toiminnallisuutta voidaan helposti laajentaa halutunlaiseksi.

C-funktiot liitetään LUAan rekisteröimällä ne luodulle LUA-virtuaalikoneelle. Tämä tapahtuu lua_register()-funktiolla. Funktio ottaa parametrinaan käytetyn virtuaalikoneen osoittimen, merkkijonon jossa kerrotaan millä nimellä haluttua funktiota kutsutaan LUA-skripteissä sekä osoittimen C-funktioon. Kaikkien rekisteröitävien C-funktioiden on oltava muotoa int FunktionNimi( lua_State* pLUAVirtuaaliKoneOsoitin ).


Esimerkkiohjelma 2

Toinen LUA-esimerkkiohjelma kutsuu kahta eri C-funktiota LUA-skriptin kautta. Ensimmäinen funktio, nimeltään OmaFunktio, ei vaadi lainkaan parametreja. Toinen funktio, nimeltään ToinenOmaFunktio, sen sijaan vaatii 2 parametria. Parametrit välitetään funktiolle LUAn sisältämien komentojen avulla. Yleisimmät parametrien välitykseen käytetyt LUA-funktiot:

[DEFTABLE]
[D]lua_tonumber()[/D][E]Palauttaa numeron (aina tyyppiä DOUBLE)[/E]
[D]lua_tostring()[/D][E]Palauttaa merkkijonon[/E]
[D]lua_toboolean()[/D][E]Palauttaa boolean-arvon (tosi/epätosi)[/E]
[/DEFTABLE]

Kaikki yllä olevista funktioista ottavat ensimmäiseksi parametrikseen käytetyn LUA-virtuaalikoneen osoittimen ja toiseksi parametriksi halutun parametrin numeron. Eli ensimmäinen numeroparametri haettaisiin käskyllä lua_tonumber( pLUAVM, 1 ) ja toisena tuleva merkkijonoparametri käskyllä lua_tostring( pLUAVM, 2 ).


Toisen esimerkkiohjelman koodi:

//---------------------------------------------
// Nimi  : Main.cpp
// Kuvaus: Toisen LUA-projektin koodi.
//---------------------------------------------
#include <stdio.h> //printf()
#include <conio.h> //getch()
extern "C"
{
#include <lua.h>
#include <lualib.h>
}


//
// Globaali muuttuja, jonka arvoa muokataan
// LUAn kautta.
//
int g_iMuuttuja;


//---------------------------------------------
// Nimi  : OmaFunktio()
// Kuvaus: Oman funktion koodi.
//---------------------------------------------
int OmaFunktio( lua_State* pLUAVM )
{
	//
	// Lisätään muuttujan arvoa ja tulostetaan
	// lopputulos ruudulle.
	//
	++g_iMuuttuja;
	printf( "OmaFunktio kutsuttu LUAsta! Muuttujan arvo %i\n", g_iMuuttuja );
	return 0;
}



//---------------------------------------------
// Nimi  : ToinenOmaFunktio()
// Kuvaus: Toisen oman funktion koodi. Nyt
//         funktiolle välitetään LUA:n kautta
//         parametreja.
//---------------------------------------------
int ToinenOmaFunktio( lua_State* pLUAVM )
{
	//
	// Luetaan parametrit virtuaalikoneelta.
	//
    int   iLuku = (int)lua_tonumber( pLUAVM, 1 );
	float fLuku = (float)lua_tonumber( pLUAVM, 2 );

	//
	// Tulostetaan saadut tiedot.
	//
	printf( "ToinenOmaFunktio kutsuttu LUAsta!\n" );
	printf( "Parametri1 = %i, parametri2 = %f\n", 
		    iLuku, fLuku );
	return 0;
}



//---------------------------------------------
// Nimi  : main()
// Kuvaus: Ohjelmakoodi
//---------------------------------------------
int main( void )
{
	//
	// Nollataan muokattava muuttuja.
	//
	g_iMuuttuja = 0;

	//
	// Luodaan LUA-virtuaalikone.
	//
	lua_State* pLUAVM = lua_open(0);
	if( pLUAVM == 0 )
		return -1;

	//
	// Otetaan LUAn peruskirjastot käyttöön.
	//
	lua_baselibopen( pLUAVM );

	//
	// Rekisteröidään LUA-koodista 
	// kutsuttavat C-funktio.
	//
	lua_register( pLUAVM, "OmaFunktio",       OmaFunktio       );
	lua_register( pLUAVM, "ToinenOmaFunktio", ToinenOmaFunktio );

	//
	// Luetaan ja tulkitaan LUA-skripti.
	//
	lua_dofile( pLUAVM, "skripti3.lua" );

	//
	// Lopuksi suljetaan LUA-virtuaalikone.
	//
	lua_close( pLUAVM );

	//
	// Odotetaan napin painallusta ennen poistumista.
	//
	getch();
	return 1;
}

--
-- C-funktion kutsuminen LUA-koodista.
--


--
-- Kutsutaan funktiota OmaFunktio()
-- joitakin kertoja. Tässä vaiheessa
-- funktio on vielä parametriton.
--
i = 0
while i < 5 
do
   OmaFunktio()
   i = i + 1
end


--
-- Kutsutaan funktiota ToinenOmaFunktio()
-- joitakin kertoja. Nyt funktiolle välitetään
-- kaksi parametria, kokonaisluku ja liukuluku.
--
i = 0
while i < 5 
do
   ToinenOmaFunktio( i, i/10 )
   i = i + 1
end

int OmaFunktio( lua_State* pLUAVM )
{
    OmaSingleton::AnnaInstanssi().TeeJotakin();
    return 0;
}

int OmaFunktio( lua_State* pLUAVM )
{
    g_pOmaLuokka->TeeJotakin();
    return 0;
}

Loppusanat #

Olemme nyt tutustuneet LUA-ohjelmointikieleen hyvin tiukassa paketissa. On paljon asioita, joita tässä artikkelissa ei käsitelty. Lisää tietoutta LUAsta, tutoriaaleja sekä teknistä dokumentaatiota, löytyy LUAn kotisivuilta osoitteessa www.lua.org.