Alkusanat

Tervetuloa QBasicin hämärään maailmaan! Olettaisin, että hallitset jo ohjelmoinnin perusteet, mutta aloittelijankin pitäisi tämän oppaan avulla päästä vauhtiin. QBasic-ohjelmointikielellä aiomme ohjelmoida yksinkertaisia ohjelmia, nopeasti ja helpohkosti. Tässä tutoriaalissa käytämme kehitysympäristönä Microsoftin vanhaa, mutta ehkä jollain tavalla toimivaa, QBasic-tulkkia, jonka voi ladata esimerkiksi osoitteesta http://www.fluid.tue.nl/student/colleges…

Kehitysympäristön käyttö kiteytettynä

QBasic-kehitysympäristön käyttö nykykoneilla saattaa olla vähän tuskaista. Tämän takia suosittelenkin käyttämään esimerkiksi DOSBoxia, jolle on olemassa omat tutoriaalinsa. Emulaattorin käyttö ei ole suinkaan välttämätöntä. Käytit sitten emulaattoria tai et, suorita QBasic.exe. Kun haluat testata ohjelmaasi, niin paina F5 tai näpäytä hiirellä Run/Start. Tallentaaksesi tiedoston klikkaa File/Save (as).

Ensimmäinen ohjelma

Tämäkin tutoriaali alkaa Hello World -ohjelmalla, joka siis tulostaa ruudulle tekstin Hello world! Koodipuoli näyttää tältä:

1
PRINT "Hello World!"

PRINT-komennolle annetaan parametrit, jotka se tulostaa ruudulle. Äskeisessä tapauksessa parametri oli merkkijono “Hello World!”

Varmasti tämän jälkeen haluat tyylikkään ja itsenäisemmän näköisen softan, joka saadaan aikaiseksi helposti tyhjentämällä ruutu ennen kirjoittamista. QBasicissa on komento nimeltä CLS, joka hoitaa homman kotiin. Jos laitat CLS-komennon ruudulle kirjoittamisen jälkeen, ohjelmasi luonnollisesti piirtää tekstin ensin ja tyhjentää ruudun vasta tämän jälkeen. Jos vahingossa teit tämän virheen, käyttäjälle ei näy muuta kuin tyhjää, joten tarkkana täytyy olla.

1
2
CLS 'Tyhjentää ruudun

PRINT "Hello World!" 'Kirjoittaa ruudulle

Maistuiko tämäkin puulta? Mielenkiintoa lisää huomattavasti hyvin yksinkertainen komento LOCATE, joka määrää PRINT-komennon kirjoittamispaikan. Oletuksenahan se aloittaa sen vasemmasta ylänurkasta (x=1,y=1), mutta LOCATEn kahden parametrin avulla voidaan kertoa, mihin teksti oikeastaan kirjoitetaan. Et ehkä arvaakaan, kuinka helposti ja nopeasti tällä saadaan peliympäristö aikaiseksi. Locaten ensimmäinen parametri on y-koordinaatti, joka kertoo kirjoituskorkeuden eli rivin. Toinen parametri on x-koordinaatti, joka viestii PRINT-komennolle tekstin vaakasuuntaisen sijainnin (sarakkeen). Parametrit annetaan ehkä aluksi epäloogiselta tuntuvalla tavalla, siis ensin y- ja sitten x-koordinaatti, mutta ilmeisesti se on perusteltu sillä, että on loogista antaa ensin rivi ja sen jälkeen sarake. Toimivat arvot ovat x-suunnassa välillä 1-80 ja y-suunnassa 1:n ja 25:n välillä.

Haluamme nyt kirjoittaa tekstin “Hello World” vaikkapa koordinaatteihin x=63, y=3, jolloin kirjoitamme LOCATE 3, 63 ennen PRINT-käskyä:

1
2
3
CLS 'Ruudun tyhjennys

LOCATE 3, 63 'Asetetaan piirtokohta riville 3, sarkaimelle 63

PRINT "Hello World!" 'Kirjoittaminen

Noita arvoja voi sitten huoletta sovellella ja muutella, kunhan pysyvät niissä määrätyissä rajoissa.

Muuttujat

Muuttuja on “arvonsäilyttämispaikka”, johon voidaan varata arvo ja jota voidaan muutella ja lukea. Voisimme esimerkiksi määritellä muuttujan ika, jonka arvoksi annetaan vaikkapa oma ikäsi. Muuttujat olisi suositeltava myös esitellä, minkä yhteydessä tulee sille antaa tyyppi. Tämä kertoo, minkälaisia arvoja se voi saada. Tässä artikkelissa käytämme usein muuttujia, jotka ovat tyypiltään on kokonaislukuja (integer).

1
2
3
4
5
Tyyppi       merkintä  Min. arvo       Max. arvo

Kokonaisluku INTEGER    -32 768         32 767

Kokonaisluku LONG       -2 147 483 647 2 147 483 647

Merkkijono   STRING     32 767 merkkiä

Liukuluku    DOUBLE

1
2
3
4
5
6
7
8
9
10
DIM ika AS INTEGER 'Määrittelee "ika"-nimisen muuttujan tyypin kokonaisluvuksi

DIM nimi AS STRING 'Määritellään muuttuja, joka on merkkijono

DIM pituus AS DOUBLE 'Määritellään muuttuja "pituus", joka on liukulukumuuttuja



ika = 7 'asetetaan sen arvoksi 7

nimi = "Erkki"

pituus = 187.3

PRINT "Nimi: ", nimi 'Tulostetaan teksti "Nimi: " ja sen perään nimi

PRINT "Ika: ", ika 'Tulostetaan "Ika: " ja ika:n arvo

PRINT "Pituus: ", pituus 'Ja vastaavasti pituus

Ehtolauseet… jotain syötävää?

Ehtolauseet ovat yksinkertaista kauraa. Niiden avulla voit tarkastella asioiden totuusarvoja. Yksinkertaista, eikö vain? QBasicin IF-lauseen rakenne näkyy seuraavassa.

1
2
3
4
5
6
IF muuttuja1 = muuttuja2 THEN 'itse ehto

'Jos ehtolause on tosi, menään tänne

ELSE 'Jos ehdon totuusarvo on epätosi, siirrytään ELSE-osioon,

                           'jonka voi jättää pois halutessaan



END IF 'Ilmoitetaan tulkille, että ehtolause loppuu tähän

Operaattoreilla saadaan erilaisia ehtoja.

1
2
3
4
5
6
7
8
Nimi                       Merkki     Esimerkki, joka palauttaa truen

---------------------------------------------------------

Yhtäsuuri kuin:              =        7 = 4+3

Pienempi kuin:               <        2 < 7

Suurempi kuin:               >        5 > 2

Yhtäsuuri tai suurempi kuin: >=       3 >= 3

Yhtäsuuri tai pienempi kuin: <=       -6 <= 9

Erisuuri kuin:               <>       1000 <> 5

Silmukat

Yksinkertaisin ja alkeellisessa peliohjelmoinnissa ehkäpä yleisin silmukka on DO-silmukka, joka suorittaa annettavaa tehtävää, kunnes suoritetaan
EXIT DO.

1
2
3
4
5
6
7
8
9
10
DIM x AS INTEGER 'Määritellään muuttuja x kokonaislukumuuttujaksi

DO 'Silmukan alkupää

  x = x + 1 'Lisätään x:ään yksi



  PRINT "x=", x 'Printataan x:n arvo

  IF x > 8 THEN 'Jos x on suurempi kuin 8, niin...

    PRINT "Päästiinhän tänne."

    EXIT DO '...päästään pois silmukasta

  END IF 'if-lauseen loppu

LOOP 'Silmukan loppupää

Kun silmukan sisään päästään, lisätään x:ään yksi, minkä jälkeen printataan sen arvo ruudulle. Ensimmäisillä kerroilla ehto x<8 ei ole tosi, joten mennään ehtolauseen ohi. Loopin lopussa hypätään takaisin alkuun. Silmukasta ei päästä pois ennen kuin x:n arvo on noussut kahdeksaan tai yli, jolloin kirjoitetaan ruudulle turhaa tekstiä ja suoritetaan EXIT DO. Tämä siis lopettaa silmukan ja näin hypätään silmukasta pois.

FOR-silmukalla voidaan toistaa jotain operaatiota n kertaa, missä n kerrotaan määrittelyssä. Kyseisen silmukan rakenne on hyvin yksinkertainen: FOR [juoksumuuttujan alustus] TO [loppuarvo] STEP [hyppyväli]. Silmukkaa suoritetaan, kunnes juoksumuuttuja on yhtäsuuri kuin loppuarvo. Joka kierros juoksumuuttujaan lisätään hyppyväli. Juoksumuuttujaa ei tulisi hyvän ohjelmointityylin mukaisesti muuttaa kesken silmukkaa, koska FOR-silmukan ideana on, että silmukan alussa tiedetään, kuinka monta kertaa silmukkaa tullaan toistamaan.

1
2
3
4
DIM i AS INTEGER

FOR i=0 TO 10 STEP 1

  PRINT "i, juoksulukumuuttujan arvo: ", i

NEXT i

INPUT? Mikäs se on?

Nyt olet varmasti halukas ottamaan syötteen vastaan komentorivitulkilta. Vähän vaikeasti oli ehkä sanottu, mutta käytännössä edellinen virke tarkoitti sitä, että voit pyytää käyttäjää kirjoittamaan tekstiä, jota voit myöhemmin käsitellä. Tätä varten on tehty INPUT-komento, jolle annetaan parametriksi yksi tai useampi muuttuja, joihin arvo asetetaan. Seuraavaksi voisimme kokeilla ohjelmaa, jolle syötetään varpaankynnen pituus, jonka perusteella ohjelma vastaa pituudesta riippuen.

1
2
3
4
5
6
7
8
9
10
11
12
DIM pituus AS DOUBLE 'Määritellään pituus-muuttuja

INPUT "Peukalovarpaankyntesi pituus? ", pituus 'Käyttäjä syöttää luvun

IF pituus < 1.5 THEN 'Jos syötetty pituus on pienempi kuin 1.5

  PRINT "Sinulla on melkoisen lyhyet kynnet!"

END IF

IF pituus > 1.5 AND pituus < 3 THEN 'Jos pituus on suurempi kuin 1.5

                  'ja pienempi kuin 3, niin

  PRINT "Kyntesi ovat normaalipituiset."

END IF

IF pituus > 3 THEN

  PRINT "Eikö kyntesi jo lohkeile?"

END IF

1. Tasaisesti muuttuva liike

Artikkelisarjan edellisessä osassa oletimme, että liike oli tasaista. Tämä ei kuitenkaan päde tositilanteessa vaan myös nopeus muuttuu ajan suhteen. Eli nopeudellakin on derivaatta ajan suhteen. Nopeuden aikaderivaattaa kutsutaan kiihtyvyydeksi (englanniksi acceleration) ja sitä merkitään symbolilla a. Lausetta ”nopeuden derivaatta on kiihtyvyys” voidaan näin ollen merkitä v’(t)=a. Koska nopeus on sijainnin derivaatta ja kiihtyvyys nopeuden, on kiihtyvyys sijainnin toinen derivaatta. Tätä merkitään: s”(t)=a. Kiihtyvyyden yksikkö on metriä sekunti toiseen (lyhenne m/s^2). Kiihtyvyys on nopeuden tapaan vektori, jonka suunta esittää kiihtyvyyden suuntaa ja pituus suuruutta.

Vastaavasti kulmanopeuden derivaattaa kutsutaan kulmakiihtyvyydeksi (englanniksi angular acceleration). Kulmakiihtyvyyden symboli on α ja yksikkö radiaania sekunti toiseen (lyhenne rad/s^2). Jos se nyt sattuu jota kuta kiinnostamaan, niin vastaavat kaavat kulmakiihtyvyydelle olisivat ω’(t)=α ja φ’’(t)=α. 2D-avaruudessa kulmakiihtyvyys on paljas luku ja 3D-avaruudessa kolme komponenttinen vektori. Siis samoin kuin kulmanopeuden tapauksessa. Jos lisäisimme kiihtyvyyden ja kulmakiihtyvyyden rakenteisiin niistä tulisi seuraavan näköiset.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
typedef struct

{

  int shape;  // Muoto. 0=ympyrä ja 1=suorakulmio

  float radius[2];  // ”Säde” metreinä.

  float position[2];  // Sijainti metreinä

  float orientation;  // Asento radiaaneina

  float velocity[2];  // Nopeus metreinä sekunnissa

  float acceleration[2]; // Kiihtyvyys

  float angularAcceleration; // Kulmakiihtyvyys

} RIGIDBODY2D;



typedef struct

{

  int shape;  // Muoto. 0=pallo ja 1=laatikko

  float radius[3];  // ”Säde” metreinä.

  float position[3];  // Sijainti metreinä

  float orientation[4];  // Asento kvaterniona

  float velocity[3];  // Nopeus metreinä sekunnissa

  float acceleration[3];  // Kiihtyvyys

  float angularAcceleration[3];  // Kulmakiihtyvyys

} RIGIDBODY3D;

Oletetaan aluksi, että kiihtyvyys on vakio ja muutetaan artikkelisarjan edellisessä osassa tehtyä simulointifunktiota ottamaan kiihtyvyys huomioon. Koska tällä kertaa myös nopeus ja kulmanopeus muuttuvat, pitää nekin käyttää integraattorin läpi eli kopioimme ne alkuarvotaulukkoon muiden perään.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void simulate2D(RIGIDBODY2D *b, float t)

{

  static float initialValue[6];

  static float output[6];

  static float temp[6*6];

  // Kopioi nykyinen sijainti, asento,

  // nopeus ja kulmanopeus alkuarvoksi.

  initialValue[0]=b->position[0];

  initialValue[1]=b->position[1];

  initialValue[2]=b->orientation;

  initialValue[3]=b->velocity[0];

  initialValue[4]=b->velocity[1];

  initialValue[5]=b->angularVelocity;

  // Integroi aika-askeleen verran. Koska ”derive” tarvitsee

  // kappaleen kiihtyvyyden, Annamme osoittimen kappaleeseen

  // ”userData” -parametrina.

  integrate(output, initialValue, 6, t, derive,

             temp, (void *)b);

  // Kopioi tulos uudeksi sijainniksi, asennoksi,

  // nopeudeksi ja kulmanopeudeksi

  b->position[0]=output[0];

  b->position[1]=output[1];

  b->orientation=output[2];

  b->velocity[0]=output[3];

  b->velocity[1]=output[4];

  b->angularVelocity=output[5];

}

Entäpä “derive” -funktio? Ei kummempia. Toteamme vain sen tosiasian, että nopeuden derivaatta on kiihtyvyys ja kulmanopeuden kulmakiihtyvyys. On kuitenkin huomioitava, että nopeuksia ei voida lukea kappaleesta ”userData” -parametrin kautta, vaan ne pitää lukea funktion saaman ”value” -parametrin kautta. Tämä tietenkin siksi, että jos integraattori kutsuu ”derive” -funktiota jollain muulla x:n arvolla kuin 0, ei nopeus muuttumisen takia enää ole sama kuin alkutilanteessa. Onneksi integraattori kuitenkin toimittaa uudet arvot value parametrin kautta, joten voimme lukea nopeuden sieltä.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void derive( float *result,

             const float *value,

             float x, void *userData )

{

  // Osoitin kappaleeseen saatiin “userData”:n kautta

  RIGIDBODY2D *b=(RIGIDBODY2D *)userData;

  // Sijainnin derivaatta on nopeus.

  result[0]=value[3];

  result[1]=value[4];

  // Asennon derivaatta on kulmanopeus

  result[2]=value[5];

  // Nopeuden derivaatta on kiihtyvyys

  result[3]=b->acceleration[0];

  result[4]=b->acceleration[1];

  // Kulmanopeuden derivaatta on kulmakiihtyvyys

  result[5]=b->angularAcceleration;

}

Tässä olikin kaikki tarvittava tasaisesti muuttuvasta liikkeestä. Todellisuudessa kiihtyvyyskään ei ole vakio, joten jatkakaamme.

2. Voima

Myös kiihtyvyys voi muuttua ajan suhteen. Emme kuitenkaan enää jatka derivointiketjua vaan etsimme syytä kiihtyvyydelle. Kiihtyvyyden voi aiheuttaa voima (englanniksi force) ja ainoastaan voima. Voiman symboli on F ja yksikkö on newton (lyhenne n). Voima on vektori, jonka suunta ilmaisee voiman suunnan ja pituus suuruuden. Kun voima vaikuttaa kappaleeseen, antaa se kappaleelle kiihtyvyyttä. Kappale ei kuitenkaan halua muuttaa liiketilaansa suosiolla vaan pistää hanttiin. Se kuinka hyvin kappale vastustaa voimaa riippuu kappaleesta. Tätä ominaisuutta vastustaa liiketilan muutosta kutsutaan hitausmassaksi tai lyhemmin vain massaksi (englanniksi mass). Massan yksikkö on kilogramma (lyhenne kg) ja symboli m. Massan olemassa oloa ei tiede vielä tänäkään päivänä osaa kunnolla selittää, mutta meidän ei tarvitse osata selittää sitä, vaan ainoastaan huomioida sen vaikutukset.

Voiman kappaleelle antama kiihtyvyys lasketaan seuraavalla <b>Newtonin liikeyhtälö</b>ksi kutsutulla kaavalla:

a=F/m

Eli kiihtyvyys on voima jaettuna massalla. Kaavasta näkee myös sen, että ei ole olemassa kappaletta jonka massa on nolla, koska nollalla ei voi jakaa. Toinen huomattava asia on, että jos olisi olemassa kappale, jonka massa on ääretön, ei se koskaan saisi kiihtyvyyttä. Tällainen kappale olisi varsin kätevä, jos haluaisimme kappaleen johon voimat eivät vaikuta. Koska a=F/m=1/m*F olisi kätevämpää tallentaa massan sijasta sen käänteisluku 1/m. Tällöin massaa ei koskaan pysty asettamaan arvoon nolla ja ääretöntä massaa voisi esittää asettamalla sen käänteisluvuksi nolla. Täydennetäänpä rakenne massan käänteisluvulla. Lisäksi voimme poistaa kiihtyvyyden rakenteesta, koska se voidaan aina tarvittaessa laskea voimista ja massasta.

1
2
3
4
5
6
7
8
9
typedef struct

{

  int shape;  // Muoto. 0=ympyrä ja 1=suorakulmio

  float radius[2];  // ”Säde” metreinä.

  float position[2];  // Sijainti metreinä

  float orientation;  // Asento radiaaneina

  float velocity[2];  // Nopeus metreinä sekunnissa

  float inverseMass;  // 1/massa kilogrammoina

} RIGIDBODY2D;

Maailmankaikkeudessa on neljä erilaista voimaa. Ne ovat: vahva ydinvoima, heikko ydinvoima, painovoima ja sähkömagneettinen voima. Kaksi ensimmäistä vaikuttavat (nimensä mukaisesti) ainoastaan atomin ytimen sisällä, joten niitä ei tarvitse ottaa simulaatioissa huomioon. Kaksi muuta sen sijaan pitää ottaa.

2.1 Painovoima

Kaikki aineelliset kappaleet vetävät toisiaan puoleensa. Voimaa, jolla aine vetää ainetta puoleensa kutsutaan painovoimaksi (englanniksi gravity). Painovoiman saa aikaan kappaleen ominaisuus, jota kutsutaan gravitaatiomassaksi. Gravitaatiomassaakin kutsutaan lyhemmin vain massaksi. Sitä ovatko gravitaatiomassa ja hitausmassa sama asia ei tiedetä. Yleisesti kuitenkin uskotaan näin olevan, joten talletamme rakenteeseemme vain yhden massan.

Kun kahden kappaleen massat ja keskipisteiden välinen etäisyys tiedetään, voidaan niiden välinen painovoima laskea kaavalla:

F=G*((m1*m2)/r^2)

Jossa m1 ja m2 ovat kappaleiden massat, r niiden keskipisteiden välinen etäisyys ja G gravitaatiovakio, jonka arvo on noin 0,0000000000667259. Koska G on hyvin pieni luku, täytyy kappaleiden massojen olla todella suuret ennen kuin niiden välinen painovoima kasvaa merkittäväksi. Tämän takia painovoima voidaan huoletta jättää huomiotta kaikille planeettaa pienemmille kappaleille.

Valitettavasti suoraan jalkojemme alla sijaitsee yksi planeetta, nimittäin Maa. Koska kaikki normaalit kappaleet ovat enemmän tai vähemmän lähellä Maan pintaa ja Maa on valtavan suuri verrattuna kaikkiin normaaleihin kappaleisiin, voidaan olettaa, että Maan painovoima antaa kaikille kappaleille suurin piirtein samanlaisen kiihtyvyyden. Tätä kiihtyvyyttä kutsutaan putoamiskiihtyvyydeksi ja merkitään yleensä symbolilla g. Putoamiskiihtyvyyden arvo on noin 9.81 (alaspäin). Ei siis tarvitse laskea maan aiheuttamaa painovoimaa ja siitä kiihtyvyyttä, vaan voidaan olettaa kiihtyvyydeksi 9.81 riippumatta kappaleesta. Tämä helpottaa laskelmia hieman.

2.2 Sähkömagneettinen voima

Jos kappaleilla on sähkövaraus niiden välillä vallitsee sähkömagneettinen voima.

Sähkömagneettinen voima lasketaan kaavalla:

F=k*(Q1*Q2)/r^2

Tässä Q1 ja Q2 ovat kappaleiden sähkövaraukset ja k sähkömagneettivakio, jonka arvo on noin 8987550000. Sähkömagneettivakio on huomattavasti suurempi kuin gravitaatiovakio, joten sähkömagneettinen voimakin on valtavan paljon vahvempi. Sähkömagneettinen voima on kuitenkin erittäin harvinainen, sillä kappaleilla ei yleensä ole sähkövarausta.

Sähkövaraus on yleinen alkeishiukkasilla ja molekyyleillä. Näin ollen sähkömagneettinen voima pitää yhdessä atomeja ja molekyylejä. Se siis pitää aineen kasassa. Tämän takia sähkömagneettinen voima ilmenee muunlaisina voimina, vaikuttamalla molekyylien välisiin sidoksiin. Tällaisia voimia ovat mm. jousivoima ja kitkavoima.

2.3 Jousivoima

Jousi on kappale, joka voi venyä ja venytyksen jälkeen pyrkii palautumaan alkuperäiseen pituuteensa. Tällaisia kappaleita ovat mm. kuminauha ja auton iskunvaimennin. Venytettynä jousi kohdistaa kumpaankin päähänsä voiman, joka lasketaan kaavalla:

F=-kx

Jossa k on jousivakio ja x jousen pituuden ja alkuperäisen pituuden erotus. Jousivakio ei ole mikään universaali vakio vaan se riippuu jousesta. Mitä suurempi vakio, sitä hankalampi jousta on venyttää.

2.4 Väliaineen vastus

Jos kappale liikkuu väliaineessa, kuten ilmassa tai vedessä vaikuttaa siihen väliaineen vastus voima. Väliaineen vastukselle voidaan esittää kaksi erilaista kaavaa riippuen siitä aiheuttaako kappaleen liike väliaineeseen pyörteitä. Jos pyörteitä ei esiinny lasketaan voima kaavalla:

F=-k*v

Jos taas pyörteitä esiintyy, lasketaan vastusvoima kaavalla:

F=-k*v^2

Kaavoissa k on jokin väliaineesta riippuva vakio. Itse asiassa tämä vakio riippuu myös kappaleen muodosta, mutta jätettäköön se huomiotta, joten voit olettaa, että k on kaikille kappaleille sama.

2.5 Esimerkki

Katsotaanpa millaiselta “derive” -funktio näyttäisi, jos kappaleeseen vaikuttaisi koko ajan yhden newtonin voima oikealle.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void derive( float *result,

             const float *value,

             float x, void *userData )

{

  // Yhden newtonin voima oikealle

  const float F[2]={ 1, 0 };

  // Osoitin kappaleeseen saatiin “userData”:n kautta

  RIGIDBODY2D *b=(RIGIDBODY2D *)userData;

  // Sijainnin derivaatta on nopeus.

  result[0]=value[3];

  result[1]=value[4];

  // Asennon derivaatta on kulmanopeus

  result[2]=value[5];

  // Nopeuden derivaatta on kiihtyvyys,

  // Joka lasketaan kaavasta F/m eli m^-1*F

  result[3]=b->inverseMass*F[0];

  result[4]=b->inverseMass*F[1];

  // Jätetään kulmanopeus toistaiseksi rauhaan

  result[5]=0;

 }

Jos kappaleeseen vaikuttaa yhtä aikaa useita voimia, voidaan nämä voimat laskea raa’asti yhteen ja käyttää kokonaisvoimana saatua tulosta.

3. Vääntömomentti

Tähän mennessä käsitellyt asiat koskivat vain kappaleen etenemisliikettä, ei sen pyörimisliikettä. Voima sai siis aikaan kiihtyvyyden. Mikähän saa aikaan kulmakiihtyvyyden? Kulmakiihtyvyyden saa aikaan vääntömomentti (englanniksi torque). Vääntömomentin yksikkö on newtonmetri (lyhenne Nm) ja symboli M. Etenevän liikkeen tavoin kappale vastustaa myös pyörimisliikkeen muutosta. Tätä ominaisuutta vastustaa pyörimisliiketilan muutosta kutsutaan hitausmomentiksi (englanniksi moment of inertia). Hitausmomentin symboli on J ja yksikkö kilogrammaa neliömetrille (lyhenne kgm^2). Kappaleen hitausmomentti riippuu kahdesta asiasta: kappaleen massasta ja muodosta. Itse asiassa hitausmomentti on ensimmäinen asia (piirtämisen lisäksi), johon varsinaisesti tarvitsemme kappaleen muotoa.

Kaikki kappaleet koostuvat atomeista, jotka ovat klassisessa fysiikassa aineen pienimpiä mahdollisia osasia. Atomin hitausmomentti lasketaan kaavalla:

atomin_hitausmomentti=atomin_massa*atomin_etäisyys_kappaleen_keskipisteestä ^ 2

Kappaleen hitausmomentti saadaan laskettua laskemalla yhteen sen kaikkien atomien hitausmomentit. Ongelmaksi kuitenkin muodostuu se, että atomeita on liian paljon käsiteltäväksi ja emme edes voi mitenkään tietää niiden kaikkien sijaintia. Onneksi kuitenkin kappaleille, jotka ovat säännöllisenmuotoisia ja joiden atomit ovat jakautuneet tasaisesti koko kappaleen alalle, voidaan muodostaa kaavat hitausmomentin laskemiseksi. Koska tässä artikkelisarjassa käytimme vain laatikoita ja palloja riittää, että annan valmiit kaavat näille kahdelle kappaleelle. En ota kantaa siihen mistä nämä kaavat tulevat.

2D-avaruudessa hitausmomentti paljas luku. Samoin kuin asento ja kulmanopeuskin eli aloitetaan 2D-tapauksesta.

Ympyrän, jonka massa on m ja säde r hitausmomentti on:

1/2*m*r^2.

Suorakulmion, jonka massa on m ja sivujen pituudet a ja b hitausmomentti on:

1/12*m*(a^2+b^2).

2D-avaruudessa hitausmomentti oli yksi paljas luku, koska pyöriminen tapahtuu aina saman “akselin” ympäri. 3D-avaruudessa pyörimisakseli voi vaihdella mielivaltaisesti, joten hitausmomenttikin muuttuu huomattavasti monimutkaisemmaksi. Kohta puolin sinun pitäisi viimeistään huomata kuinka valtavan paljon helpompaa kaikki on 2D-avaruudessa verrattuna 3D-avaruuteen.

3D-avaruudessa hitausmomentti on 3×3 matriisi. Matriisi tarkoittaa taulukkoa, mikäli et sitä vielä tiennyt. Eli 3×3 matriisi on taulukko, jossa on kolme riviä ja kolme saraketta. Matriisi voidaan helpointen tallentaa tietokoneella käyttämällä 9 komponenttista yksiulotteista taulukkoa, johon matriisin alkiot tallennetaan sarakkeittain. Seuraavassa on kaavat tämän matriisin muodostamiseksi pallolle ja laatikolle.

Pallon, jonka massa on m ja säde r hitausmomentti olisi:

Laatikon, jonka massa on m ja sivujen pituudet a, b ja c hitausmomentti olisi:

Tämä ei kuitenkaan vielä riitä! 3D-avaruudessa hitausmomentti muuttuu sitä mukaa kun kappale pyörii. On siis otettava asento huomioon. Hitausmomentista J voidaan laskea asentokvaternion φ avulla lopullinen asennon huomioon ottava hitausmomentti J2 kaavalla:

J2 = matriisiksi(φ) * J * matriisiksi(φ)^T

Kvaternio, jonka komponentit ovat w, x, y ja z muutetaan matriisiksi kaavalla:

Ja sama koodina:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void generateQuaternionMatrix(float m[9], const float q[4])

{

  float xx=q[1]*q[1];

  float xy=q[1]*q[2];

  float xz=q[1]*q[3];

  float xw=q[1]*q[0];

  float yy=q[2]*q[2];

  float yz=q[2]*q[3];

  float yw=q[2]*q[0];

  float zz=q[3]*q[3];

  float zw=q[3]*q[0];



  m[0] = 1 - 2 * ( yy + zz );

  m[1] =     2 * ( xy + zw );

  m[2] =     2 * ( xz - yw );

  m[3] =     2 * ( xy - zw );

  m[4] = 1 - 2 * ( xx + zz );

  m[5] =     2 * ( yz + xw );

  m[6] =     2 * ( xz + yw );

  m[7] =     2 * ( yz - xw );

  m[8] = 1 - 2 * ( xx + yy );

}

Merkintä “^T” taas tarkoittaa matriisin transpoosia, joka lasketaan pyöräyttämällä matriisi vinottaisakselinsa ympäri. Seuraavassa transponointi koodina.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void transposeMatrix(float m[9])

{

  float temp;

  DWORD i, j;

  for (i=0; i< 2; i++)

  {

    for (j=i+1; j< 3; j++)

    {

      temp=m[j+3*i];

      m[j+3*i]=m[3*j+i];

      m[3*j+i]=temp;

    }

  }

}

Nyt on jäljellä enää matriisien kertolaskua. Kaksi 3×3 matriisia voidaan kertoa keskenään seuraavan kaavan mukaisesti.

Ideana oli siis kertoa rivit ja sarakkeet keskenään ja summata tulokset. Tässä sama koodina:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void glmMultMatrix3f(float result[9], const float m1[9], const float m2[9])

{

  float sum;

  int x, y, i;

  for (x=0; x< 3; x++)

  {

    for (y=0; y< 3; y++)

    {

      sum=0;

      for (i=0; i< 3; i++) sum+=m1[y+3*i]*m2[3*x+i];

      result[y+3*x]=sum;

    }

  }

}

Huh huh! Olipa monimutkaista. Aina kun tarvitsemme kappaleen hitausmomenttia muutamme kappaleen asennon matriisiksi ja laskemme asento*hitausmomentti*asennon_transpoosi, jolloin saamme oikean hitausmomentin.

Samoin kuin massankin tapauksessa, ei ole olemassa kappaletta, jonka hitausmomentti on nolla ja kappale, jonka hitausmomentti on ääretön, on immuuni vääntömomentille, joten tallennetaan hitausmomentin sijasta sen käänteisluku. 2D-avaruudessa tämä on helppoa, mutta 3D-avaruudessa pitää ottaa käänteismatriisi. 3×3 matriisin käänteismatriisi lasketaan seuraavalla kaavalla:

Kaavassa |M| tarkoittaa matriisin determinanttia, joka taas puolestaan lasketaan kaavalla

Seuraavassa samat koodina:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
float determinant(const float m[9])

{

  return

    -m[6]*m[4]*m[2]+

     m[3]*m[7]*m[2]+

     m[6]*m[1]*m[5]-

     m[0]*m[7]*m[5]-

     m[3]*m[1]*m[8]+

     m[0]*m[4]*m[8];

}



void generateInverseMatrix(float i[9], const float m[9])

{

  float x=determinant(m);

  if (x==0) return;



  i[0]=(-m[7]*m[5]+m[4]*m[8])/x;

  i[3]=( m[6]*m[5]-m[3]*m[8])/x;

  i[6]=(-m[6]*m[4]+m[3]*m[7])/x;

  i[1]=( m[7]*m[2]-m[1]*m[8])/x;

  i[4]=(-m[6]*m[2]+m[0]*m[8])/x;

  i[7]=( m[6]*m[1]-m[0]*m[7])/x;

  i[2]=(-m[4]*m[2]+m[1]*m[5])/x;

  i[5]=( m[3]*m[2]-m[0]*m[5])/x;

  i[8]=(-m[3]*m[1]+m[0]*m[4])/x;

}

Täydennetään nyt rakenteet hitausmomentilla. 3×3 matriisi on tallennetaan 9 alkioisena taulukkona, johon matriisi tallennetaan sarakkeittain.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
typedef struct

{

  int shape;  // Muoto. 0=ympyrä ja 1=suorakulmio

  float radius[2];  // ”Säde” metreinä.

  float position[2];  // Sijainti metreinä

  float orientation;  // Asento radiaaneina

  float velocity[2];  // Nopeus metreinä sekunnissa

  float inverseMass;  // 1/massa kilogrammoina

  float inverseMomentOfInertia; // 1/hitausmomentti

} RIGIDBODY2D;



typedef struct

{

  int shape;  // Muoto. 0=pallo ja 1=laatikko

  float radius[3];  // ”Säde” metreinä.

  float position[3];  // Sijainti metreinä

  float orientation[4];  // Asento kvaterniona

  float velocity[3];  // Nopeus metreinä sekunnissa

  float inverseMass;  // 1/massa kilogrammoina

  float inverseMomentOfInertia[9]; // 1/hitausmomentti

} RIGIDBODY3D;

Kulmakiihtyvyys lasketaan vääntömomentista ja hitausmomentista kaavalla:

α=M/J

Eli kulmakiihtyvyys on vääntömomentti jaettuna hitausmomentilla. Huomaat varmaan yhtäläisyyden kaavaan a=F/m. Sama kaava pätee niin 2D- kuin 3D-avaruudessakin. 2D-avaruudssa kaikki olivat paljaita lukuja, joten laskeminen ei tuottane ongelmia. 3D-avaruudessa α ja M ovat kolme komponenttisia vektoreita ja J 3×3 matriisi, joten kaavan laskeminen vaatinee hieman selvitystä. Koska α=M/J=J^-1*M ja meillä sattui sopivasti olemaan J^-1 valmiina, tarvitsee vain kertoa 3×3 matriisilla 3 komponenttinen vektori. Tämä tehdään kaavalla:

Vielä sama koodina:

1
2
3
4
5
6
void multMatrixWithVector(float result[3], const float m[9], const float v[3])

{

  result[0]=m[0]*v[0]+m[3]*v[1]+m[6]*v[2];

  result[1]=m[1]*v[0]+m[4]*v[1]+m[7]*v[2];

  result[2]=m[2]*v[0]+m[5]*v[1]+m[8]*v[2];

}

Maailmassa oli siis 4 perusvoimaa, joiden ilmentymiä kaikki voimat olivat. Onkohan maailmassa sitten 4 perusvääntömomenttiakin? Kenties painovääntömomentti ja sähkömagneettinen vääntömomentti? Ei ole. Vääntömomentti nimittäin johtuu aina voimasta. Voima aiheuttaa vääntömomentin, jos voima ei kohdistu kappaleen keskipisteeseen tai tasaisesti kappaleen kaikkiin pisteisiin. Voimista painovoiman, sähkömagneettisen voiman ja väliaineen vastuksen voidaan katsoa vaikuttavan kappaleen keskipisteeseen (tai tasaisesti sen kaikkiin pisteisiin). Sen sijaan jousivoima vaikuttaa siihen pisteeseen, jossa jousi on kiinni. Jos voima kohdistuu pisteeseen p ja kappaleen keskipiste sijaitsee pisteessä x, lasketaan voiman aiheuttama vääntömomentti kaavasta:

Koska 2D-tapauksessa vektorit olivat kaksikomponenttisia ja kahden vektorin ristitulon voi laskea vain kolme komponenttisilla vektoreilla, pitää kaksi komponenttisista vektoreista tehdä väkisin kolme komponenttisia. Tämä tehdään lisäämällä niihin yksi ylimääräinen komponentti, jonka arvoksi laitetaan nolla. Ristitulon laskemisen jälkeen vastaus saadaan tulosvektorin kolmannesta komponentista, kahden muun ollessa nolla.

Jos voimia on useita, lasketaan vääntömomentti jokaiselle voimalle erikseen ja sitten vääntömomentit lasketaan yhteen.

4. Vakausongelmat ja vaimennus

Kuten jo artikkelisarjan ensimmäisessä osassa totesimme, numeerinen integraattori ei anna täydellisen oikeita tuloksia vaan ainoastaan likimääräisiä vastauksia. Tämän takia saattaa jostain syystä käydä niin, että integraattori antaa kokoajan aavistuksen verran liian isoja tuloksia. Tällöin virheet kasaantuvat seuraavan virheen ollen aina edellistä suurempi ja lopulta integraattori sylkee ulos äärettömyyksiä. Sanotaan, että integraattori “räjähtää”. Tällainen tilanne, jos ei kaataisi, niin ainakin sotkisi simulaation. Jos taas integraattori antaisi koko ajan aavistuksen verran liian pieniä tuloksia, ei tilanne ole läheskään niin paha. Silloin kappaleen vauhti vain pikkuhiljaa pienenee.

Välttääksemme räjähtämisen pitää keksiä jotain tilanteen vakauttamiseksi. Yksi tällainen keino on vaimennus (englanniksi damping). Vaimennuksen idea on pienentää integraatorin antamia tuloksia aavistuksen, jolloin ne eivät ainakaan ole liian suuria. Tämä estää räjähtämisen, ellei integraattori ammu aivan metsään, kuten Eulerin menetelmä yleensä tekee. Haittapuolena taas on, että tämän seurauksena liike koko ajan hieman pienenee lopulta pysähtyen. Tämä ei kuitenkaan yleensä haittaa sillä kappaleiden liikkeen pysähtyminen vastaa havaintojamme oikean elämän liikkeestä, joka tosiaankin aina lopulta hiljenee. Oikeassa elämässä liikkeen hiljenemisen aiheuttaa kitkavoima, josta puhumme vasta artikkelisarjan viimeisessä osassa. Varsinkin väliaineen vastusta voi käyttää helposti vaimentimena.

Seuraavassa muutama sääntö pitämään virheet mahdollisimman pienenä.

1. Pidä aika askel pienenä. Integraattori antaa sitä tarkempia vastauksia, mitä pienemmillä x:n arvoilla sitä kutsutaan.
2. Pidä voimat pienenä. Suuret voimat aiheuttavat suuremman virheen kuin pienemmät.
3. Älä käytä Eulerin menetelmää!

Yksi hyvä keino simulaation vakauden tarkkailuun on energian säilymislaki. Se sanoo, että energiaa ei voi luoda tai hävittää ainoastaan muuttaa muodosta toiseen. Kappaleen energia voi olla kolmessa eri muodossa. Ne ovat liike-energia, pyörimisenergia ja potentiaalienergia.

Liike-energia lasketaan kaavalla: 1/2*m*v^2

Pyörimisenergia lasketaan kaavalla: 1/2*J*ω^2

Potentiaalienergiaa kappaleella on jokaista voimaa vastaan. Se riippuu siis voimista. Maan vetovoimaa vastaan oleva potentiaalienergia lasketaan kaavalla: mgh. h on kappaleen korkeus maasta. Sillä mistä pisteestä h mitataan, ei ole väliä, sillä emme tarvitse potentiaalienergian absoluuttista arvoa. Meidän täytyy ainoastaan tutkia pysyykö sen arvo muuttumattomana. Jousivoimaa vastaan potentiaalienergia lasketaan kaavalla: kx^2. Kaavassa k on jousivakio ja x jousen pituuden ja oikean pituuden erotus.

Kun lasket nämä kolme eri energiatyyppiä yhteen, pitäisi tuloksen olla koko ajan vakio. Jos näin ei ole antaa integraattori virheellisiä arvoja, kuten lähes aina käy.

Huomaa, että väliaineen vastus ja kitka muuttuvat energiaa lähinnä lämmöksi, jota ei tässä otettu huomioon, joten ne vähentävät energia. Ilman näitä voimia energian pitäisi kuitenkin säilyä.

5. Esimerkkiohjelma

Tällä kertaa esimerkkiohjelmamme on jo aavistuksen verran edellistä kiinnostavampi. Esimerkkiohjelma demonstroi jousivoimia, painovoimaa ja niiden vaikutusta kappaleisiin. Simulaattorissa ”katosta” roikkuu kuminauhojen varassa muutamia kappaleita.

2D-esimerkkihjelman voit ladata tästä: f22d.zip

3D-esimerkkiohjelman voit ladata tästä: f23d.zip

6. Loppusanat

Tässä osassa opit voimista ja niiden vaikutuksesta kappaleen liiketilaan. Seuraavassa osassa puhumme törmäyksistä.

Raportoithan kaikki tästä artikkelista löytämäsi virheet (niin kirjoitus-, kuin asiavirheetkin) osoitteeseen markus.ilmola@pp.inet.fi , niin korjaan ne mahdollisimman nopeasti. Myös kaikki kommentit ja kysymykset ovat tervetulleita.

Lopuksi linkkejä, joissa lisää luettavaa tähän mennessä opituista asioista.

Suomenkielinen selostus erilaisista voimista:
http://butler.cc.tut.fi/~lassila/johdatu…

David Baraffin vallan mainio artikkeli “Physically Based Modeling”. Osa 1.
http://www-2.cs.cmu.edu/~baraff/sigcours…

Chriss Checkerin hieman suppeampi artikkeli. Osat 1 ja 2.
http://www.d6.com/users/checker/pdfs/gdm…
http://www.d6.com/users/checker/pdfs/gdm…

Noniin, jatketaanpa sitten peliohjelmoinnin perusteiden harjoittelemista. Tiedän, että sinulla jo sormet syyhyävät päästä koodia näpyttelemään ja väsäämään seuraavaa hittipeliä, mutta usko pois, aika jonka käytät näiden yksinkertaisten ja tylsienkin asioiden opettelemiseen ei ole hukkaan heitettyä.

Viime kerralla käytiin läpi ristinollapelissä tarvittavat tietorakenteet; päädyimme käyttämään taulukkoa pelilautana ja tietuetta pelaajan tietojen tallentamiseen. Nyt jatkamme tästä vähän eteenpäin. Tämän osan aiheena on pelisilmukka ja pelin rakenteen suunnittelu. Eli vieläkään ei saada aikaan valmista peliä, mutta osan lopussa ollaan sitä kuitenkin jo paljon lähempänä.

Pelin toiminta

Aloitetaanpa siitä, että mietitään hetkinen mitä tietokone tekee suorittaessaan peliäsi. Tietokoneessahan on prosessori, joka suorittaa käsky kerrallaan ohjelmaa, keskusmuisti ja paljon muita hässäköitä.

Kun prosessori suorittaa ohjelmaa, tapahtuu se erittäin yksinkertaistetussa muodossa seuraavasti: Ensin se hakee muistista yhden käskyn, sitten se suorittaa sen ja tallentaa tuloksen johonkin rekisteriinsä tai keskusmuistiin. Siinä välissä tapahtuu vielä paljon kaikkea muutakin, mutta idea on siinä, että kone suorittaa koodia käskyn kerrallaan alusta loppuun.

Oleellista tuosta on huomata se, että ohjelman täytyy olla aika tarkkaan mietitty, koska tietokone suorittaa sitä ihan orjallisesti. Se ei pysty soveltamaan yhtään vaan kaikki täytyy kertoa sille tarkkaan.

Mutta ei mennä ainakaan vielä ihan niin laitteistonläheisiksi vaan mietitään hetkinen sitä kuinka itse pelaisit ristinollaa kaverisi kanssa:

• Ensin toinen teistä piirtää ruksin paperiinsa
• Sitten toinen
• Sitten taas ensimmäinen

Ja tuota jatketaan kunnes jompikumpi saa tarvittavan kolmen merkin rivin. Vaikka tuo ohje riittäisi ihmiselle, koneella ei ole tarvittavaa mielikuvitusta sen ymmärtämiseen. Tarkennetaanpa siis määritystämme hieman:

1. Aloitetaan peli: haetaan paperia ja kynä.
2. Päätetään kumpi aloittaa
3. Pelaaja laittaa rastin haluamaansa kohtaan
4. Jos hän yrittää piirtää rastinsa sellaiseen kohtaan, jossa jo on merkki, se ei onnistukaan – vaan kaveri ärähtää, “Mitä oikein yrität?”
5. Kaverukset tarkistavat, onko jompikumpi jo saanut tarvittavat 3 ruutua
6. Jos on, peli loppuu
7. Muuten tarkistetaan, onko ruudukko täynnä
8. Jos on, peli loppuu
9. Jos ei, pelaaja vaihtuu ja jatketaan kohdasta 2

Tuossa on sama juttu hieman tarkennettuna. Se antaa jo aika hyvän kuvan siitä mitä ohjelman pitää tehdä. Tätä voitaisiin pitää yksinkertaisena suunnitteluna. En tässä käytä mitään hienoja termejä, kun tarkoituksena on yrittää herättää ajatteluasi siihen suuntaan, että pelien suunnittelu ja asioiden huomioiminen onnistuisi kuin luonnostaan.

Pelisilmukka

Äskeisestä peliesimerkistä päästäänkin varsin luontevasti siirtymään pelisilmukkaan. Peliähän siis pelataan tietty aika, tarkalleen ottaen siihen asti, että toinen pelaaja voittaa tai tulee tasapeli. Sinä aikana tehdään monta kertaa samat asiat; kumpikin laittelee merkkejään ja tarkistellaan onko joku jo mahdollisesti voittanut. Tässä siis kannattaa käyttää silmukkaa. Oletan, kuten jo ensimmäisessä osassa sanoin, että sinulla on perustiedot ohjelmoinnista. Silmukan käsite lienee siis selvä: jotain ohjelmanpätkää toistetaan kunnes jokin ehto täyttyy, esimerkiksi peli loppuu.

Pseudokoodina, eli ohjelmakoodina, jonka ei ole tarkoitus sellaisenaan toimia vaan antaa suuntaa siitä miten lopullinen ohjelma toimisi, voisimme kirjoittaa pelisilmukan vaikkapa näin:

pelaaja=1;

while(peli_jatkuu)
{
	while(pelaaja laittaa laittomaan ruutuun)
		laita_merkki_haluamaasi_ruutuun();

	voittaja=tarkista_voittaja();	

	if(voittaja!=0) peli_jatkuu=false;

	else pelaaja=vaihda_pelaaja();
}

Okei, esimerkissämme ei vielä otettu oikeastaan mitään kantaa siihen, kuinka se käytännössä on mahdollista toteuttaa. Näppäimistön luku, grafiikat ja muu mukava on vielä kokonaan pois. Kyse on siis puhtaasti logiikasta, siitä kuinka ajattelemme pelin parhaiten toimivan. Koodin selitys voisi olla paikallaan.

Silmukassa tehdään aina yhden pelaajan siirto ja sen jälkeen tarkistetaan voittiko kyseinen pelaaja. Sen jälkeen, jos peli edelleen jatkuu, vaihdetaan pelaajaa ja mennään silmukkaa läpi toisen kerran. Tarkista_voittaja() -pseudofunktio palauttaa voittajan numeron (1 tai 2), jos joku voittaa ja 0, jos peli jatkuu. Tasapelitilanteessa se voisi palauttaa vaikkapa kolmosen. Vaihda_pelaaja() asettaa pelaajan numeroksi seuraavan pelaajan numeron. Ja tuo while(pelaaja laittaa laittomaan ruutuun) tarkoittaa sitä, että laita_merkki_haluamaasi_ruutuun() toistetaan niin monta kertaa, että pelaaja lopulta laittaa merkkinsä johonkin sallittuun ruutuun.

Jaetaan koodi osiin

Ennen kuin tehdään lopullista versiota tuosta pelisilmukasta, käsitellään hieman funktioita ja sitä kuinka ohjelmaa kannattaa jakaa funktioiksi. Siis mitkä ohjelman osat tarvitsevat oman funktionsa ja miten funktioista saadaan paras hyöty irti. Oletan, että tiedät tekniikan, kuinka funktioita käytetään ja keskityn vain tähän teoriapuoleen.

Funktiojako on sellainen asia, jonka puuttumiseen tai vaillinaiseen ymmärtämiseen törmään useimmiten aloittelevien ohjelmoijien koodia lukiessani. Monesti mukana on joku funktio, esimerkiksi alkutekstien kirjoittamiseen – tekijä kun on kuullut, että on hienoa käyttää funktioita. Ja niinpä sellainen on pitänyt mukaan ahtaa. Funktioiden merkitys on kuitenkin jostain syystä jäänyt kuulematta. Sen takia paneudun nyt hetkeksi funktioihin. Asia ei ole monimutkainen – ja se helpottaa ohjelmointityötäsi HUOMATTAVASTI!

Funktioihin jakamiseen on oikeastaan kaksi tärkeää syytä: saman koodin uudelleenkirjoittamisen välttäminen ja koodin jakaminen sellaisiin osiin, jotka on helppo käsitellä, ja ne kummatkin oikeastaan voitaisiin yleistää selkeydeksi. Funktioita käytetään, jotta koodi olisi selkeämpää ja sitä olisi helpompi hallita. Yleensä tällä saavutetaan bugittomampaa koodia, helpommin korjattavaa koodia ja monesti myös paljon paremmin toimivaa koodia.

Jos katsotaan funktioihin jakamista ensin hetki uudelleenkirjoittamisen näkökulmasta, huomataan, että usein ohjelmissamme toistamme samoja operaatioita moneen kertaan. Esimerkiksi, jos käytämme pelissämme grafiikkaa ja meidän täytyy ladata kuvia, lataamme luultavasti pelin aikana monta kuvaa. Kuvanlatausfunktioon tulee helposti muutama kymmenen riviä koodia ja jos se kirjoitetaan joka kerta uudestaan, kun taas tarvitaan kuvaa, pitenee ohjelmamme aivan turhaan. Nimittäin, jos teemme funktion, joka ottaa parametrinaan kuvan tiedostonimen ja palauttaa kuvan (esim. DirectDrawn surfacessa), meidän tarvitsee kirjoittaa vain kerran tuo kymmenkunta riviä, ja aina kuvaa ladattaessa kutsua tuota funktiota.

Tästä pääsemmekin helposti myös siihen selkeyteen ja ylläpidettävyyteen. Ajattele, että sinulla olisi ohjelma, jossa ladataan 20 kuvaa, ja jokaisen kuvan lataamiseen käytettävä koodi olisi aina kirjoitettu siihen kohtaan, jossa kuvaa tarvitaan. Sitten yhtäkkiä huomaisit, että kuvanlatauskoodissasi on virhe. Noh, ei muuta kuin tekisit korjaukset kaikkiin 20 kohtaan. Aikaa menisi ehkä puoli tuntia. Mutta entä, jos kuvia olisi 50 – tai sata. Siinä menisivät jo hermot. Jos sen sijaan olisit laittanut kuvan latauksen funktioon, tarvitsisi korjata vain sieltä, ja ongelma poistuisi kaikista kuvista. Aikaa menisi ehkä 5 minuuttia. Tietenkin ongelman suuruudesta riippuen.

Toinen juttu on sitten se koodin jakaminen selkeisiin, helposti käsiteltäviin osiin. Kun puhutaan koodin ymmärrettävyydestä, ajatellaan yleensä kommentteja. Aloittelija ei usko edes niitä tarvitsevansa, johtoajatuksena on saada äkkiä jotain toimivaa näkyviin. Mutta selkeys ja ymmärrettävyys on paljon enemmänkin. Se on sitä, että ohjelmakoodi on jaettu funktioihin, jotka tekevät sen mitä niiden oletetaan tekevän. Ne tekevät pieniä osatehtäviä niin, että ohjelmoijan on helppo pääohjelmaa katsoessaan yhdellä silmäyksellä nähdä kuinka sen logiikka toimii. Tätä asiaa haluan erityisesti tässä tutoriaalissa korostaa: kun joku lukee koodiasi, tulisi hänen pystyä saamaan ainakin suurpiirteinen käsitys ohjelmasi toiminnasta vilkaisemalla pääohjelmaasi – tai ainakin pelisilmukkaasi.

Siksi pelisilmukkaan tulee laittaa vain välttämätön, ja kaikki muu jaettava selkeisiin funktioihin. Ja funktioiden pitää olla sellaisia, että niiden toiminta on loogista.

Mitä funktioita tarvitaan?

Noniin, mietitäänpä mitä ristinollapelissämme olisi järkevää laittaa omiin funktioihinsa. Ensinnäkin olisi tärkeää erotella piirtäminen ja pelin muu toiminta. Sen lisäksi voisi olla hyvä erottaa näppäinten luku pelin sääntöjen ja logiikan käsittelystä. Pelisilmukassa voisi olla siis vaikkapa seuraavat funktiot:

• PISTE Lue_hiiri() – lukee hiiren painalluksen ja palauttaa koordinaatit, joihin hiirellä on klikattu
• bool Tee_siirto(PISTE p, int pelaaja, PELILAUTA lauta) – muuttaa hiiren koordinaatit pelilaudan koordinaateiksi, tarkistaa voiko ko. ruutuun laittaa merkin ja merkitsee ruutuun pelaajan tunnuksen. Jos taas ruutuun ei voi laittaa (siinä on jo jonkun merkki), palauttaa funktio virheen merkiksi false. Tällöin täytyy hiiri lukea uudelleen.
• int Tarkista_voittaja(PELILAUTA lauta) – käy läpi pelilaudan ja tarkistaa onko joku voittanut. Palauttaa voittajan numeron tai 0, jos kukaan ei vielä ole voittanut. Tasapelistä se palauttaa 3.
• void Piirra_pelitilanne(PELILAUTA lauta, int pelaaja) – piirtää näytölle pelilaudan, ja kirjoittaa tiedon siitä kumman pelaajan vuoro on.

Siinä on jonkin verran tärkeimpiä funktioita. Kuten huomaat, ne ovat varsin loogisia kokonaisuuksia: siirron tarkistaminen, voittajan tarkistaminen, piirtäminen jne. Ei vaadi kovin paljon miettimistä, että keksii jakaa ohjelman juuri tuollaisiin osiin. Parametrit ovat lähinnä suuntaa-antavia, mutta varmaankin aika lähellä lopullisia parametreja.

Ihmettelet ehkä, miksi hiiren lukeminen ja siirron tarkastaminen ei ole samassa funktiossa. Ne kun kuitenkin aika läheisesti liittyvät toisiinsa. Toki ohjelman voisi kirjoittaa niinkin, että hiiri luettaisiin tee_siirto-funktiossa, mutta yleensä suositaan sitä tapaa, että kaikki laitteistonläheinen osa ohjelmasta sijoitetaan erilleen abstraktimmasta osasta. Tämä sen takia, että jos vaikkapa joskus haluat siirtää Windowsissa tekemäsi pelin Linuxiin, on se helppo tehdä, kun ei tarvitse kuin muuttaa niitä laitteistonläheisiä osia – logiikka pysyy ihan samana.

Tehdäänpä nyt se silmukka

Nyt meillä lienee tarpeeksi teoriaa funktioiden jakamisesta, ja voidaan alkaa soveltamaan niitä käytäntöön. Tärkeintä on muistaa, että pyritään kaikessa selkeyteen ja helposti ymmärrettävään koodiin. Harjoitus tekee mestarin, tärkeintä vain on se, että muistaa aina miettiä asioita – eikä vain tehdä niin kuin ensimmäisenä mieleen tulee.

Eli kerätään edellisissä osissa esitellyt tietotyypit ja tässä osassa mietityt funktiot yhteen ja kasataan ristinollapelillemme pääohjelma (main). Kommenteissa kerrotaan kaikki tarpeellinen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/* Ristinollapelin pääohjelma - versio 1

   Huom! Tämä ei vielä ole toimiva ohjelma, vaan

   pelkkä pääohjelma, jonka ympärille myöhemmin

   rakennetaan kokonainen peli */



/* Määritellään PELIMERKKI-tietotyyppi */

typedef enum { RISTI, NOLLA } PELIMERKKI; 



/* Määritellään PELAAJA-tietue (ks. tutoriaalisarjan 2. osa) */

typedef struct _PELAAJA

{

    char nimi[40];

    PELIMERKKI nappula;

} PELAAJA; 



/* Määritellään PISTE-tietue, jota käytetään

   hiiren lukemiseen */

typedef struct _PISTE

{

    int x, y;

} PISTE;



int main(void)

{



    int voittaja=0; /* Voittajan numero - 0=peli ei vielä loppunut */

    PELAAJA pelaajat[2]; /* Kaksi pelaajaa */

    int pelilauta[3][3]; /* Pelilauta */

    PISTE piste; /* Tätä käytetään hiiren tietojen välitykseen */

    int vuorossa = 1; /* Vuorossa oleva pelaaja (1 tai 2) */



    /* Alustetaan pelaajien arvot (kumpi on risti / nolla yms.) */

    alusta_pelaajat(pelaajat);



    /* Alustetaan pelilauta (nollataan kaikki sen ruudut) */

    alusta_pelilauta(pelilauta);



    /* Koska pelissä käytetään grafiikan piirtoon ja hiiren lukuun

       Allegro-kirjastoa, täytyy sekin alustaa tässä ennen kuin

       aloitetaan pelisilmukkaa */

    alusta_allegro();



    /* Pelisilmukka: Pyöritään ympäri ja ympäri niin

       kauan kunnes voittaja-muuttujan arvo muuttuu

       (1=pelaaja 1 voitti, 2=pelaaja 2 voitti ja 3=tasapeli) */



    while(voittaja==0)

    {

        /* Tehdään logiikka, jos hiirellä on klikattu johonkin,

           muuten vain piirretään */

        if(lue_hiiri(&piste))

        {

            /* Ks. tee_siirto()-funktion esittely yllä */

            if(tee_siirto(&piste, pelilauta, vuorossa))

            {

                /* Tarkistetaan voittiko pelaaja tällä

                   siirrollaan ja jatkuuko peli vielä */

                voittaja = tarkista_voittaja(pelilauta);



                /* Seuraavan pelaajan vuoro */

                vuorossa = vaihda_pelaaja(vuorossa);

            }



            /* Jos siirto ei ollut sallittu, tehdään

               piirto ja aloitetaan taas silmukan alusta */

        }



        /* Piirretään pelin grafiikat */

        piirra_pelitilanne(pelaajat, pelilauta);

    }



    /* Pelin lopetus: Kerrotaan kuka voitti - vai tuliko tasapeli,

       tehdään muut lopetustoimet */



    kerro_voittaja(voittaja);



    lopeta_allegro();



    return 0;

}

Selitän ohjelmaa hieman, mutta en paljon, koska oikeastaan siinä on vain laitettu käytäntöön sellaisia asioita, joista tuossa edellä on puhuttu. Pääohjelmaan siis kuuluu oikeastaan kolme osaa: Alku, jossa alustetaan käytetyt muuttujat ja tehdään kaikki valmistelut, Pelisilmukka, jossa tehdään itse peli ja Lopetus, jossa viimeistellään pelin suoritus ja tehdään lopetustoimet.

Alku ja loppu tehdään vain kerran, kun taas pelisilmukkaa käydään läpi niin kauan kuin peliä kestää. Siksi erityisesti pelisilmukka on tärkeää suunnitella hyvin ja selkeäksi.

Pelisilmukasta tein sellaisen, että piirto tehdään joka kerta, vaikka peli ei etenisikään, siksi että silloin, kun pelaaja liikuttelee hiirtä näytöllä, mutta ei paina mitään nappia, täytyy piirtää, mutta peli ei kuitenkaan etene. Niinpä suurin osa pelisilmukasta suoritetaan vain silloin, kun hiirtä klikataan.

Myös tee_siirto() aiheuttaa sen, että osa koodista joko suoritetaan tai hypätään yli sen mukaan oliko siirto sallittu. Jos siirto ei ollut sallittu, ei kannata tarkistaa voittajaa tai vaihtaa pelaajaa. Silloin vain piirretään ja sama pelaaja saa taas yrittää uudestaan. Jos vaikka tällä kertaa osuisi oikeaan ruutuun.

Miten jatketaan?

Niin, tämä osa alkaa olla tässä. Opettelimme sitä kuinka pelisilmukka tulisi rakentaa ja miten pelin toiminta jaetaan funktioihin. Samalla teimme peliimme pääohjelman rungon, jonka päälle alamme ensi kerralla kasaamaan hieman lihoja – kirjoittamaan funktioita. Tuo runko ei itsessään vielä tee mitään, eikä sitä pysty edes kääntämään, mutta se on jo askel kohti valmista peliä.

Seuraavassa osassa toteutamme siis pelin logiikkaan liittyvät funktiot tee_siirto(), tarkista_voittaja() ja vaihda_pelaaja(), sekä alustusfunktiot alusta_pelaajat() ja alusta_pelilauta(). Sitä seuraavalla kerralla luomme pikaisen katsauksen grafiikkaan Allegroa hyödyntäen, kuitenkin niin, että Allegron tekniikalla on siinä mahdollisimman pieni osuus, ja saamme pelin valmiiksi.

Ei muuta kuin opetteluintoa, ja hauskaa koodausta! Palautetta saa ja pitää antaa – vaikkapa suomipelit.com:in keskustelualueella. Yritän sitten artikkelia vielä parannella ja ainakin vastailla kysymyksiisi.

Artikkelin kirjoitti alun perin jalaine.

Mikä on SDL?

SDL eli Simple Direct media Layer on DirectX:ään verrattavissa oleva kirjasto. SDL-kirjastot löytyvät tällä hetkellä Linuxille, Windowsille (9x,2k,Xp), MacOS:lle ja BeOS:lle. SDL on Open Sourcea, mutta tämä ei tarkoita että SDL:ää käyttävän sovelluksen lähdekoodia pitäisi julkaista (muistaakseni tätä kutsutaan LGPL:ksi). Useimmat Linuxille portatut kaupalliset pelit (Tribes2, Descent3, http://www.lokigames.com) käyttävät SDL:ää

Miksi minun pitäisi käyttää sitä?

SDL:llä ohjelmointi on huomattavasti helpompaa kuin DirectX:llä, DirectX:ssä pitää huolehtia ns. Windows-tauhkasta (sovellusikkunoiden hallinasta jne.). DOS-ohjelmointi taas on luonteeltaan hieman erilaista. Mutta DOS? Haloo et kai tosissasi halua tehdä pelejä jotka toimivat DOS:ssa? On olemassa mysös muita kirjastoja kuten allegro, mutta se ei pärjää SDL:lle.
SDL:ään saa ilmaisia lisäkirjastoja (Osoitteesta http://www.libsdl.org), jotka tukevat esim. kehittyneempiä musiikki- (.ogg, .mp3, .xm, midi jne.) ja kuvaformaatteja (.png, .gif, .jpg jne.)

SDL-kirjastojen asennus

Ensin tarvitaan SDL-binääri- ja kehityspaketit, jotka löytyvät http://www.libsdl.org :sta. Asennus tapahtuu eri käyttöjärjestelmissä hieman eri tavoin:

Windows:
Tarvitset SDL:n peruskirjastot SDL-1.2.3-win32.zip (http://www.libsdl.org,  Download/SDL 1.2/Runtime Libraries/w32), sekä kehityskirjastot (Visual C++ 6.0) SDL-devel-1.2.3-VC6.zip (http://www.libsdl.org, Download/SDL 1.2/Development Libraries/w32)

Pura SDL-1.2.3-win32.zip (siis sitä readme-SDL.txt fileä ei tuola tietenkään tarvita) windowsin system-hakemistoon (NT,w2k,Xp system32)

Pura SDL-devel-1.2.3-VC6.zip esim. c:\SDL-1.2.3 -hakemistoon

Linux:
Tarvitset SDL:n peruskirjastot SDL-1.2.3-1.i686.rpm (http://www.libsdl.org, Download/SDL 1.2/Runtime Libraries/Linux), sekä kehityskirjastot (gcc) SDL-devel-1.2.3-1.i686.rpm (http://www.libsdl.org, Download/SDL 1.2/Development Libraries/Linux)

Asenna rpm-paketit komennoilla:

rpm -Uvh SDL-1.2.3-1.i686.rpm

ja

rpm -Uvh SDL-1.2.3-1.i686.rpm

Paketit asentuvat paikkaan X ja kaikki kirjastojen vaatimat conffaukset tehdään automaattisesti.

Koodaamaan!

Windows:

1. Luodaan uusi projekti (new Win32 application / empty project )
2. Viritetään Visual c++ -asetukset kuntoon: Valitse Tools/Options/Directories ja pudotusvalikosta include files ja lisää siihen hakemisto, jossa SDL:n header-tiedostot sijaitsevat (C:\SDL-1.2.3\include). Seuraavaksi valitse library files ja lisää hakemisto jossa SDL-kirjastot ovat (C:\SDL-1.2.3\lib).
3. Valitse Project/Settings/ C/C++ -välilehti, lehdeltä löytyy “Category” valikko. Valitse siitä code generation, vaihda “Use run-time library:” Multithreaded DLL:ksi.
4. Valitse Project/Add to Project/Files ja lisää kirjastot SDL.lib ja SDLmain.lib (c:\SDL-1.2.3\lib)
5. Koodia kehiin, kääntämään

Linux:
Linuxilla (Mandrake 8.1) emme lähde rakentamaan projektia, käymme siis suoraan käsiksi koodiin:

Koodi kääntyy komennolla: gcc -o main main.cpp -lSDL

Alla oleva koodi kääntyy molemmissa ympäristöissä:

Linuxissa voit joutua muuttamaan rivin

#include <SDL.h>

seuraavaksi

#include <SDL/SDL.h>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <SDL.h>



SDL_Surface *screen_surf;



void ShowBMP(char *file, SDL_Surface *screen, int x, int y)

{

    SDL_Surface *image; // oma surface kuvalle

    SDL_Rect dest; //alue, jolla määritetään kuvan kopioitavan datan mitat



    /* Load the BMP file into a surface */

    image = SDL_LoadBMP(file);

    if ( image == NULL ) {

        fprintf(stderr, "Not found  %s: %s\n", file, SDL_GetError());

        return;

    }



    /* kopioidaan kuvadata ruudulle. */

    dest.x = x;

    dest.y = y;

    dest.w = image->w;

    dest.h = image->h;

    SDL_BlitSurface(image, NULL, screen, &dest);



    /* paivitetaan ruutu */

    SDL_UpdateRects(screen, 1, &dest);



    /* poistetaan kuva muistista */

    SDL_FreeSurface(image);

}



int main( int argc, char* argv[] )

{

    //luodaan surface ruudulle

    // kokoruututila |SDL_FULLSREEN flagilla

    screen_surf = SDL_SetVideoMode(640, 480, 16, SDL_SWSURFACE);



         if ( screen_surf == NULL )

    {

            fprintf(stderr, "Unable to set 640x480 video: %s\n",

                         SDL_GetError());

    }



    ShowBMP("kuva.bmp",screen_surf,0,0); //ladataan kuva

    SDL_Delay(5000);  //odotetaan 5 sekuntia



    SDL_Quit();

    return 0;

}

Mitäs meillä nyt jo on kasassa?

Niinpä. Tämä kakkososa on jo käytännössä loppu, mutta otetaanpa vielä lyhyt kertaus ennen seuraavaan lukuun jatkamista. Pohdimme tässä osassa siis tietorakenteita, joita ristinollapelissämme tulemme tarvitsemaan, ja päädyimme siihen, että pelilauta on taulukko ja pelaaja tietue. Lisäksi kokeilimme pientä tietueenkäsittelyohjelmaa. Seuraavassa osassa jatkamme pelin rakenteeseen, eli ruvetaan oikeasti ohjelmoimaan peliä, tai paremminkin pelin runkoa, joka kuitenkin jo toimii – jotenkin :) Kiitoksia seurasta ja kärsivällisyydestä, moi! Jees. Olet nyt varmaankin lukenut ensimmäisen osan tästä peliohjelmointikurssista ja valmis ottamaan askelen eteenpäin. Jos et edellistä osaa ole lukenut, suosittelen siihen palaamista vielä ennen tämän tekstin lukemista. Nimittäin, vaikka se saattaakin tuntua paikoin tylsältä ja epäoleelliselta, on ykkösosan asioiden ymmärtäminen hyvän lopputuloksen kannalta tärkeää. Joka tapauksessa oletan, että olet sen lukenut tai muuten vaan ymmärrät suunnittelun perusasiat.

Tässä osassa mennään siis eteenpäin erittäin tärkeään asiaan. Vaikka vielä ei ainakaan ihan heti ruvetakaan koodaamaan, puhutaan paljon C-kielestä, ja ajatellaan jo toteutuksen kannalta äärimmäisen tärkeää asiaa: tietoa, ja sen tallennusta. Osasta ei luultavasti tule kovin pitkä, koska ristinollassa emme mitään kovin ihmeellisiä tietorakenteita käytä. Mutta mitä tässä enää jaarittelemaan, aloitetaan!

Tietoa ja tietorakenteita

Eiköhän aluksi tehdä selväksi mitä tiedolla tässä yhteydessä tarkoitetaan. Tieto kun voi tarkoittaa niin montaa asiaa. Mietipä hetki itse, ja kirjaa vaikka paperille mieleesi tulevia ristinollassa käsiteltyjä tietoja! Tuliko listastasi jotain tämän näköistä?

• Ei mitään..

Jos tuli, ei se mitään. Ajattelet tietoa hieman eri tavalla kuin mitä nyt on tarkoitus ajatella :). Nimittäin kun ajatellaan tietoa pelin kannalta, se tarkoittaa niitä aivan yksinkertaisia asioita, joita tavallisesti emme välttämättä edes kovin paljon ajattele. Ristinollan tapauksessa tällaisia asioita ovat mm. seuraavat:

• Pelilauta / -tilanne
• Pelaajat
• Pelimerkit
• Pisteet

Luultavasti alkuperäinen listasikin muistutti enemmän tätä toista listaa, vai kuinka? Mennään kohta tarkemmin siihen, että minkälaisia tietorakenteita voidaan käyttää näiden tietojen säilyttämiseen, mutta pohditaan ensin mitä nämä tiedot oikeastaan ovat.

Pelilautahan on ruudukko, jossa on joko 3×3 ruutua tai sitten enemmän. Koskapa ekassa osassa utelemiani ajatuksia pelilaudan koosta ei tullut, päätin sitten itse, että kyllä meille tässä vaiheessa riittää 3×3 -ruudukko. Miksi päädyin tähän tulokseen selviää seuraavassa luvussa. (Vähän jännitystä ;). Miksi laitoin pelilaudan ja pelitilanteen samalle riville? Tähän on ihan hyvä syy; pelilautahan ristinollassa kertoo pelitilanteen, koska pelilautaan merkitään missä kohti on kenenkin pelimerkki.

Sitten pelaajat. Jos pelaajien pelimerkkien paikat määritetään pelilaudassa, niin mitä hyötyä on pelaaja-tietotyypistä. Ei paljonkaan, mutta kuitenkin jotain. Onhan johonkin tallennettava pelaajan nimi, pelaajan pelimerkki (onko se x vai 0 vaiko joku muu?) ja muuta hauskaa tietoa pelaajasta.

Pelimerkit ja pisteet voidaan hylätä, koska ne sisältyvät jo edellisiin tietotyyppeihin eikä niitä sen vuoksi tarvitse erikseen olla – eikä ristinollassa muutenkaan lasketa pisteitä!

Pelilauta taulukkoon

Kaikkein yleisin tietotyyppi heti muuttujan jälkeen on taulukko. Hmm.. Tiedät varmaan mikä taulukko on, mutta otetaanpa esimerkki:

+-+-+-+
| | | |
+-+-+-+
| | | |
+-+-+-+
| | | |
+-+-+-+

Tuohan siis on 3×3 -taulukko, juuri sellainen mitä ristinollassa tulemme tarvitsemaan. Sen luominen C-kielellä tapahtuu seuraavasti:

int pelilauta[3][3];

Näin. Miksikö tein tuosta taulukosta int-tyyppisen? Okei.. Varsinkin, kun pelimerkit ovat kirjaimia, olisi voinut olla helppoa tehdä merkkitaulukko, jolloin taulukkoon olisi voinut tallentaa suoraan pelimerkin. Ajattelin kuitenkin, että voisi olla mielekkäämpää tallentaa taulukkoon aina sen pelaajan numero, kuka on pelimerkkinsä laittanut, ja sitten hakea pelimerkki pelaajatiedoista. Eli tähän tapaan:

+-+-+-+
|1|0|2|
+-+-+-+
|2|2|0|
+-+-+-+
|1|0|1|
+-+-+-+

Kaikki tyhjät ruudut ovat siis nollia. Aika järkevää, eikö vain? Taulukoista ei nyt tämän enempää. Kunhan päästään toteutukseen, kerron tarkemmin kuinka taulukoita luetaan ja niihin sijoitetaan. Nyt riittää, kun ymmärrät miksi käytämme taulukkoa ja mikä taulukko oikeastaan edes on.

Monimutkaisempia tietorakenteita

Okei. Pelilauta on siis taulukko, johon tallennetaan pelitilanne sitä mukaa, kun peli etenee. Mutta mikä on sitten pelaajan tietotyyppi? Mitenkäs olisi tietue? Jos tietue kuulostaa vieraalta, selitän sen nyt. Tietue (struct) on eräänlainen tietokokoelma, jonka sisään voidaan koota kaikenlaista yhteenkuuluvaa tietoa, tietotyypistä riippumatta. Mietitäänpä mitä tietoa pelaajasta haluamme tallentaa.

• Nimi
• Ikä :)
• Pelimerkki
• Pisteet

Esimerkiksi tuollaisia.. Tähän asti luultavasti olet tuollaisia tietoja käsitellyt ihan yksittäisinä muuttujina tai taulukoina, nimihän olisi tietysti merkkijonotaulukko:

char nimi[50];

Eikös vain? Ja ikä ihan tavallinen int-muuttuja. Tai jos haluttaisiin enemmän tarkkuutta, kävisi myös floatti tai vaikka double :). Samoin pisteet, mutta pisteitähän emme halunneet tallentaa, joten — mitenkäs se tuonne taas pääsikään livahtamaan? ;-)

Entäs sitten Pelimerkki? Se voisi olla vaikka char-muuttuja johon tallennetaan x tai 0. Mutta koska emme kuitenkaan aio pelistä tekstipohjaista tehdä, olisi x:ien ja nollien kanssa temppuilu turhaa. Mitä merkkejä ristinollassa siis voi olla? Ristejä ja nollia! Vain kaksi vaihtoehtoa. Niinpä tehdään oma luettelotietotyyppi, kas näin:

typedef enum { RISTI, NOLLA } PELIMERKKI;

Nyt voimme luoda PELIMERKKI-tyyppisiä muuttujia jotka voivat sisältää jommankumman noista arvoista RISTI tai NOLLA, esimerkiksi tällä tavoin:

PELIMERKKI nappula;

nappula=RISTI;

Huomaatko mitä hyötyä tästä on? Jos et, älä huoli, se selviää myöhemmin, ja onhan toki muitakin yhtä hyviä tapoja, esimerkiksi yksinkertaista int-muuttujaa voi käyttää.
Mutta nyt siihen pääasiaan eli tietueihin. Meillä on tuossa kaikenlaista tietoa, mutta sitä on aika hankala käsitellä tuollaisina palasina, joten kootaanpa muuttujat yhteen, tietueeksi:

1
2
3
4
5
6
7
typedef enum { RISTI, NOLLA } PELIMERKKI;



typedef struct _PELAAJA

{

    char nimi[50];

    PELIMERKKI nappula;

} PELAAJA;

Tuossa on nyt pelaajan tiedot yhdessä nätissä kasassa. Samoin kuin PELIMERKKEJä voidaan nyt myös PELAAJia luoda:

PELAAJA pelaaja_1;

strcpy(pelaaja_1.nimi,"Jarkko");
pelaaja_1.nappula = RISTI;

Näin yksinkertaisesti se toimii. Kun PELAAJA-tyyppinen tietue, pelaaja_1 (esim), on luotu, voidaan sen sisältämiin kohteisiin (muuttujiin yms.) viitata kirjoittamalla tietueen nimi, piste ja tietueen sisältämän muuttujan nimi. Niinkuin tuossa esimerkissäkin näkyy: pelaaja_1.nappula = RISTI;. Se on näin helppoa. Jos strcpy-funktio hämää, kerron siitä sen verran, että sehän on yksi C:n standardifunktioista, oma suosikkini ;). Se kopioi ensimmäisenä parametrina annettuun merkkijonoon, toisena parametrina annetun merkkijonon, eli tässä tapauksessa nimi-muuttujaan nimen “Jarkko”..

Kootaan palaset

Jotta tämä ei kaikki jäisi ihan teorian tasolle, tehdäänpä nyt pieni ohjelma tietueita käyttäen. Ei vielä itse ristinollapeliä, mutta jotain mukavaa kuitenkin. Niin, no voihan tätäkin siinä pelissä sitten käyttää, eli sellainen systeemi, joka kyselee pelaajan nimeä ja tallentaa sen sitten pelaaja-tietueeseen. Niinkuin yleensäkin, tee ohjelma ensin itse ja vasta, kun se on valmis tai ei toimi, katso tästä. En ole jaksanut koodia sen kummemmin piilottaa, mutta älä silti kurki ;)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/* Esimerkkiohjelma 1

   ------------------

   (C) Jarkko Laine 2000

 */



#include <stdio.h>



/* Määritellään PELIMERKKI-tietotyyppi */

typedef enum { RISTI, NOLLA } PELIMERKKI;



/* Määritellään PELAAJA-tietue */

typedef struct _PELAAJA

{

  char nimi[40];

  PELIMERKKI nappula;

} PELAAJA;



int main(void)

{

   PELAAJA pelaaja1; /* Ykköspelaajan tiedot */

   char merkkijono[100]; /* Merkkijono syötteiden lukemista varten */



  /* Kysytään käyttäjältä nimeä */

   printf("Mikä on nimesi? ");



   /* Luetaan vastaus fgets() -funktiolla. Se toimii siten, että se lukee

      ensimmäisenä parametrina annettuun merkkijonoon syötettä viimeisenä

      annetusta tietovirrasta kunnes painetaan enteriä. Kuitenkin enintään

      kakkosparametrin verran merkkejä. stdin on standardisyötevirta eli

      normaalisti näppäimistö */

   fgets(merkkijono,100,stdin);



   /* Kopioidaan syötetty nimi pelaajan nimeksi */

   strcpy(pelaaja1.nimi, merkkijono);



   /* Ja tulostetaan kokeeksi käyttäjälle */

   printf("Jaa-a. Nimesi on siis %s\n",pelaaja1.nimi);



   /* Kysellään vielä pelimerkkiä */

   printf("Haluatko käyttää (x) ristiä vai (0) nollaa? ");



   /* Luetaan koko rivi, koska saattaahan joku hyvinkin kirjoittaa

      pitkänkin rimpsun tekstiä :) */

   fgets(merkkijono,100,stdin);



   /* Tutkitaan kuitenkin vain ekaa merkkiä.. Tätä voisi hyvinkin laajentaa

      paljon paremmaksikin, mutta eiköhän tämä tähän hätään riitä.. */

   if(merkkijono[0] == \'x\') pelaaja1.nappula = RISTI;

   else if(merkkijono[0] == \'0\') pelaaja1.nappula = NOLLA;



   /* Näin, ja sitten vielä tarkistetaan että mikäs se oikein oli tuo

      pelaajan valitsema nappula.. Switch-lauseella, ihan huvin vuoksi :) */

   switch(pelaaja1.nappula)

   {

      case RISTI:

      {

        printf("Valitsit siis RISTIN.\n");

      } break;



      case NOLLA:

      {

        printf("Valitsit siis NOLLAN.\n");

        break;

      }



      default: break;

   }



   return 0;

}

Semmoisen ohjelman kyhäsin minä.. Sinun ohjelmasi ei tarvitse olla samanlainen, tietoa kun voi hyvinkin kysellä myös muilla funktioilla kuin fgets():illä. Itse vain olen siihen mieltynyt :).

Artikkelin kirjoitti alun perin jalaine.

Mihin tässä ollaan ryhtymässä

Selvä, haluat siis tehdä pelin. Hyvä idea sinänsä. Tässä tutoriaalisarjassa yritän opettaa sinulle mahdollisimman monia hyödyllisiä tietoja ja taitoja, jotka auttavat sinua tekemään parempia pelejä, toivottavasti :). Minun täytyy sen verran kuitenkin sinua pudotella maanpinnalle, että tiedät, ettet vielä heti aluksi voi saada aikaiseksi mitään sellaista mitä kaupan hyllyllä näet. Ne on sitten jo ihan eri luokassa, jotain mitä saatat tehdä kun olet 5-6 vuotta pelejä ohjelmoinut – tai jotain..

Mutta älä säikähdä, voimme silti tehdä vaikka mitä hauskaa, kunhan muistamme ettemme tavoittele liian korkealle, muistathan sananlaskun:

Joka kuuseen kurkottaa, se katajaan kapsahtaa

Tässä tapauksessa se tarkoittaa sitä, että aloitetaan ristinollasta. Ajattelin aluksi matopeliä, mutta sain hyviä neuvoja GameDev.net:in keskustelualueilla, ja niiden pohjalta päätin aloittaa vielä vähän helpommasta. Matopeli voisi olla sitten seuraava askel.

Ainoana perustietona tällä kurssilla edellytän C-kielen alkeiden taitamista. Tarkemmin sanottuna sinun on osattava ainakin seuraavat käsitteet:

• Funktiot, ja maini
• Muuttujat
• Taulukot
• Tietueet
• For, While ja do-while
• if, else

Jos jotain noista asioista et osaa, on sinun parasta se opetella, koska ne ovat C:n olennaisimpia asioita. Tietueet opetan luultavasti tässä kurssissa ihan alusta asti, mutta silti ne on hyvä osata. Pointterit opetan myös tällä kurssilla, jos niitä tullaan tarvitsemaan. Joka tapauksessa enempi tietämys C-kielestä ei koskaan ole pahaksi!

Tässä kurssissa pyrin painottamaan tiettyjä yleisesti hyväksyttyjä toimintatapoja ja -malleja sekä tyyliseikkoja. Samalla toivon, että tämä kurssi voisi johdattaa sinut alusta asti oikeaoppiseen peliohjelmointiin, kertomalla sinulle minkälaisia tietorakenteita ja moduulisuunnittelullisia seikkoja sinun tulisi ottaa huomioon peliäsi suunnitellessa ja toteuttaussa. Esimerkeissä käytän C:tä ja ilmaista Allegro-kirjastoa, johtuen sen helppokäyttöisyydestä. Kaikki asiat pitäisi kuitenkin pystyä soveltamaan myös missä tahansa muussa ympäristössä. Tämä ensimmäinen osa käsittelee idean kehittelyä ja suunnittelua. Aloitetaan!

Pistä koneesi pakettiin

Joskus kauan sitten oli MikroBitissä moniosainen peliohjelmointikurssi, en muista milloin, mutta siitä voi hyvinkin jo kymmenen vuotta olla. Siinä oli aika hyvä neuvo, joka mielestäni sopii tähän yhteyteen vallan mainiosti:

Ennen kuin alat koodaamaan, pistä koneesi pakettiin ja lähetä se postissa itsellesi

Aivan tarkkaa sanamuotoa en muista, mutta idea oli tuo.. Tietystikin siihen aikaan koneet olivat pienempiä, joten ne pystyi helpommin lähettämään itselleen postissa. Matkaan kului kuitenkin aikaa ainakin viikko, joten jäi aikaa suunnitteluun eikä tullut sännättyä suoraan koneen kimppuun.. Tuskinpa tuota kukaan sananmukaisesti totteli, mutta ehkä joku kuitenkin tajusi pysähtyä hetkeksi miettimään, että “hei, mitäs oikeastaan aionkaan tehdä?”

Kaikki alkaa ideasta. Jos sinulla ei ole harmainta aavistustakaan siitä, mitä haluat tehdä, todennäköisesti et mitään saakaan aikaiseksi. Ja huonosta ideasta luultavasti tulee huono peli :). Niinpä siis ihan aluksi kannattaa ainakin muutama hetkonen uhrata ihan sen pohtimiseen, että mitä oikeastaan haluan tehdä. Jos tämän voi tehdä tiimityönä niin aina vain parempi – yksin niin helposti takertuu yhteen ajatukseen eikä mieti yhtään sen pidemmälle. Kaikkia keskustelussa esiin tulevaa tulee jollain tavoin pohtia ja ottaa huomioon, tässä tutoriaalissa käytän esimerkkinä omaa muunnelmaani Ted Nelsonin esittämästä ideamatriisista, mutta sinä voit vallan mainiosti tehdä suunnitelmasi ihan millä tavalla vain haluat.

Mutta mistä saada ideoita? André LaMothe esittää kirjassaan Windows Game Programming For Dummies seuraavanlaisen listan:

• Muista peleistä
• Elokuvista ja videoista
• Todellisista peleistä
• Unista ja painajaisista

Siinä on siis muutamia ihan hyviä idean lähteitä, mutta varmasti on paljon muitakin hyviä paikkoja etsiä ideoita: kirjat, sarjakuvat ja ihan mikä vaan mikä tulee mieleen. Muista peleistä ideoita otettaessa on muistettava, että ei ole mitään järkeä lähteä koko peliä kopioimaan. Itse suosittelisin mielummin keksimään idean jostain muualta kuin muista peleistä (vaikkakin itse juuri teen BoulderDash-kloonia ;), koska Doom-klooneja on nähty jo aivan tarpeeksi – eikö?

Ideasta eteenpäin

Hankalampaa kuin idean keksiminen, on kuitenkin sen kehittely ja pohtiminen. Jokainen idea ei välttämättä sellaisenaan ole hyvä. Mutta katsotaanpa esimerkkipelimme ideankehittelyn alkuvaiheita.

Kuvitelkaamme, että olemme keksineet aivan mahtavan idean: tehdään tietokoneversio koulutuntien suosikkipelistä jätkänshakista! Tämä on hyvä idea, mutta mikä oikeastaan on jätkänshakki? Ajattelin aluksi, että olisin tässä kohti esittänyt tällaisen ideamatriisitekniikan, jonka Ted Nelson, eräs kuuluisa amerikkalainen tutkija, esitti luennoidessaan joku aika sitten täällä Jyväskylässä.. Se kuitenkaan ei tähän oikein sopinut, joten käydään asiaa hieman eri tavalla läpi.

Koska ideamme on jo hyvin tunnettu peli, ei meidän varmaan kovin paljon tarvitse pelin peruskäsitteitä pohtia. Aloitetaan kuitenkin muutamalla kysymyksellä, joita kannattaa aluksi pohtia.

• Mitä pelaajat tekevät voittaakseen?
• Kuinka monta pelaajaa on mukana?
• Mikä pitää pelin kiinnostavana?

Joo, nuo tuntuvat varmaan aika tyhmiltä kysymyksiltä, mutta pohditaanpa niitä hetkinen. Pelaajat siis haluavat saada aikaiseksi suoria, mutta kuinka pitkiä suoria? Kaikista perinteisimmässä versiossa suorat ovat kolmen mittaisia:

x| |o
-+-+-
o|x|
-+-+-
o| |x

Tuohon tapaan siis. Mutta kaikkihan tietävät, että jos kaksi vähänkään parempaa pelaajaa pelaavat tuota peliä keskenään, ei kukaan voi koskaan voittaa! Siksipä pelistä on olemassa laajempi versio, jossa pelataan isommalla ruudukolla ja pyritään 5 merkin suoriin. Miten teemme tässä pelissä? Meillä on siis nyt valinnan paikka, ja annan sinun itse miettiä miten kannattaisi tehdä. Jos valitset 3×3-ruudukon, on luultavasti toteutus hieman helpompi, mutta toisaalta se voi olla pelaajien mielestä tylsempi. Toisaalta taas tekoälyn toteuttaminen tällaiseen ruudukkoon on helpompaa.

Kuinka monta pelaajaa? Tähän kysymykseen ei ainakaan voi olla montaa eri vastausta, eihän? Voi! Tuli tuossa eilen tätä pohtiessani mieleeni ajatus, että mitäs jos pelattaisiin kolmella pelaajalla. Idea tuntui aluksi aika erikoiselta, mutta pohdin sitä eteenpäin.. Tällä saisi kolmaskin kaveri tekemistä eikä tarvitsisi vain katsella odottelemassa. Ensimmäinen ajatukseni olikin, että “hei, tuohan voisi olla loistava ajatus!”. Mutta sitten veljeni pudotti minut maanpinnalle sanoen: “Jarkko, jos se kerran on niin hyvä ajatus, niin miksi kukaan ei sitä olisi aikaisemmin keksinyt?”. Niinpä, hyvä pointti. Niinpä asetuimme hetkeksi keittiönpöydän äärelle kokeilemaan peliä. Ensin pelasimme niin, että oli kolme pelaajaa ja yritettiin saada 5 ruudun rivejä. Se oli aika hankalaa, koskapa kaksi pelaajaa pystyi aina torjumaan kolmannen pelaajan rivit. Niinpä jonkin aikaa kokeiltuamme päätimme kokeilla neljän ruudun riveillä, ja se oli jo paljon parempi juttu. Kovin pitkälle kokeiluissamme emme vielä päässeet, joten en tiedä vielä tuleeko esimerkkipeliimme kolminpeli vai ei. Laita kommentteja, ja erityisesti tutki asiaa! Päätetään sitten yhdessä miten tästä jatketaan!

Mikä tekee tästä pelistä hyvän

Äskeisessä luvussa käsittelimme ideoita, ja ideoiden kehittelemistä ja hiomista. Se saattoi tuntua hieman ylimalkaiselta tai turhalta, kun oli kiire ohjelmoimaan ja tekemään peliä. Kuitenkaan sitä ei pidä ohittaa hätäisesti. Idea on kuitenkin loppujen lopuksi se mikä tekee pelistä hyvän tai huonon. Jos nyt tuntuu siltä, että ohitit ideankehittelyvaiheen turhan hätäisesti, palaa vielä edelliseen lukuun ja ideakaavioidesi pariin!

Nyt kuitenkin alamme jo hieman miettiä sitä miten ideaa lähdetään suunnittelemaan valmiiksi peliksi. Varsinaisia teknisiä ratkaisuja emme tee vielä, koska emme tunne tarpeeksi käsitteitä ja asioita sitä varten. Sen sijaan pohdimme muita tärkeitä, ylemmän tason asioita, sellaisia, jotka ovat ehkä lähinnä käyttäjää ja siten ehkä jopa kaikista tärkeimpiä. Älä käsitä väärin, totta kai näiden suunnitelmien toteutus on tärkeää myöskin, mutta ilman tätä suunnittelua on peliä huomattavasti vaikeampi toteuttaa!

Mikä on se mikä tulee erottamaan tämän pelin massasta? Miksi juuri tämä peli olisi niin hyvä, että kaikkien kannattaisi sitä pelata? Näitä kysymyksiä pohdittaessa kannattaa miettiä myös, että mikä oikeastaan on tietokonepeli. Niin, mikä on tietokonepeli? Ted Nelson (jota luultavasti tässä kurssissa vielä moneen kertaan tulen lainaamaan :) sanoi, että tietokonepelit ovat kaikista parhaita tietokoneohjelmia, todellista interaktiivista ohjelmistoa. Miksi näin? Hän sanoi sen johtuvan siitä, että toisin kuin muita ohjelmia, tietokonepelejä tehdään tunteella ja siksi ehkä hieman paremmin. Mutta mikä on se mikä tekee pelistä interaktiivisen ja paremman kuin jonkin hyödyllisen ohjelman? Se on käyttäjän huomioiminen! On erittäin tärkeää, että pelaaja tuntee, että hän osaa ja pystyy pelaamaan peliä ilman että hänen tarvitsee lukea tuhatsivuista tai edes sivun mittaista ohjekirjaa.

Siis… Miten tehdä pelistä sellainen että se miellyttää käyttäjää ja että hän tuntee heti olevansa “kotonaan” pelin äärellä? Ensimmäiseksi, mikä tulee olemaan pelin kohderyhmä? Kenelle peli on tarkoitettu. Tämä on tärkeä tehdä selväksi heti projektin alkuvaiheissa, koska kaikkia ei voi miellyttää. Siispä mieti, kuka tätä peliä tulee pelaamaan (vastaus voi olla ihan mikä vaan, esimerkiksi naapurin mummo, tai vaikka vain sinä ja pari kaveriasi – tai ehkä jopa suuri joukko nuoria rullaluisteluammattilaisia :). Kaikista helpointa varmaan on tehdä peliä samanlaisille ihmisille kuin itse olet. Mutta mieti tätä tarkkaan. Tämän päätöksen tehtyäsi voit paljon helpommin miettiä minkä tyylistä grafiikkaa peliin pitäisi tulla, minkälaista musiikkia – ehkä juonenkäänteitä. Kaikkeen tähän vaikuttaa kohderyhmän valinta.

Sitten, (ei mennä vieläkään ohjelmoinnin puolelle..:), mikä on pelin juoni/tarina tms? Miksi pelaaja pelaa peliä? Tämän kurssin peliin on tosi vaikea keksiä mitään järkevää tarinaa, mutta kyllä sitäkin voi miettiä. Jos keksit jotain hyvää, pistä postia ja kerron siitä seuraavassa osassa. Mutta edetäänpä käyttöliittymään, siihen minkä välityksellä kaikki käyttäjän ja pelin välinen vuorovaikutus tapahtuu. Siihen osaan peliä, joka ensimmäiseksi näkyy käyttäjälle päin.

Ristinollassakin on käyttöliittymä

Pelialue voidaan jakaa esimerkiksi näin

Miten peliä pelataan? Käytetäänkö näppäimistöä, vai olisiko hiiri parempi? Miten peli esittää tilanteet käyttäjälle? Tässä vaiheessa kannattaa luultavasti pistää ideoita paperille ja piirrellä jokunen kuvakin käyttöliittymästä. Tässä pieni hahmotelma, jonka itse tätä kurssia varten piirtelin.

Okei, tuo ei ole mikään maailman mahtavin kuva, eikä sen ole tarkoituskaan sellainen olla.. Se on itse asiassa aika hutaisten tehty, ja toivoisinkin että sinä miettisit hieman pitempään ja suunnittelisit jotain vähän parempaa. Kuitenkin tuossa on muutamia ihan järkeviä perusajatuksia. Pelialue on siinä oikealla sellainen ruutupaperimainen ruudukko, johon hiirellä klikkaamalla laitellaan ristejä ja nollia. Ja sitten, kun saadaan suora aikaiseksi, voitetaan. Tuttuun tapaan ihan niinkuin koulussa.

Ylhäällä vasemmassa nurkassa lukee tilannetietoja, kuten kenen vuoro on, miten kauan on pelattu ja niin edelleen. Vasemmalla alareunassa on valikot. Siitä voi painaa nappulaa, josta alkaa uusi peli tai nappia josta peli loppuu. Lisäksi voidaan keksiä vielä pari muuta hauskaa nappulaa.

Vielä on muutamia tärkeitä asioita joita täytyy miettiä:

• Minkälaista grafiikkaa tullaan käyttämään? (liittyy tavallaan tuohon äskeiseen kuvaan.. joskin hieman laajempana asiana)
• Onko peli yksin- vai moninpeli?
• Missä järjestelmässä ja minkälaisilla koneilla peliä tullaan käyttämään?

Pohdittuasi näitä kysymyksiä koita vielä keksiä jokunen muu kysymys, jota pelaaja voisi mielessään ajatella ja etsi niihin järkeviä ja hyviä vastauksia. Kirjoita kaikki nämä asiat paperille ja laita paperi talteen sellaiseen paikkaan, josta voit sitä seurata jatkuvasti pelisi kehittyessä. Se toimikoon eräänlaisena käsikirjoituksena pelisi kehittyessä, kuin sääntökirjana. Toki siihen voi aina tehdä muutoksia, mutta mieluiten vain hyvin pieniä ja kosmeettisia.
Tehtäväsi tämän osan lopussa on pohtia näitä asioita ja kirjoittaa niistä tällaista suunnitteluraporttia, pistää ideat paperille, etteivät ne unohtuisi. Ajattelin, että tästä voisi tehdä hieman interaktiivisemman kurssin kuin tavallisesti. Joten ennen kuin kirjoitan seuraavan osan, toivoisin saavani sinulta palautetta ja erityisesti ideoita siitä, minkälainen sinun pelistäsi tulee. Mitä olet pohtinut? Siis, jos kirjoitat suunnitteluraporttisi koneella, lähetä se ihmeessä minulle, niin voin sitä tutkia ja mahdollisesti kommentoida. Mutta erityisesti, jotta tietäisin mitä asioita kannattaa tämän kurssin edetessä käsitellä, jotta saat kurssista mahdollisimman paljon irti!

Kiitos, että jaksoit seurata koko ensimmäisen osan loppuun asti, nyt vain töihin. Seuraava osa tulee mahdollisimman pian.

Artikkelin kirjoitti alun perin jalaine.

Koska kyseessä on opetustarkoitukseen tehty artikkeli, ei kaikki sen sisältämä koodi ole suoraan oikeaan ohjelmaan soveltuvaa ja muutenkin pääasiana on selkeys, ei tehokkuus.Artikkeli on pyritty jakamaan sopivan kokoisiin osioihin ja jokainen läpikäyty asia on pyritty selvittämään mahdollisimman selkokielisesti ilman aiheelle ominaisia monimutkaisia vieraskielestä johdettuja termejä. Lähdekoodi esimerkit on testattu Microsoft Visual C++ 6.0 ohjelmointiympäristössä.

Esimerkkien kääntymisen onnistuminen vaatii oikein asennetun WIN32 ohjelmointikirjastojen olemassaoloa.

Koko artikkelin lähdekoodeineen voit imuroida tästä: artikkeli000.zip.Varsinkin DOS-ympäristössä ohjelmointia tehneille Windows on aluksi hieman mystinen viesteineen ja monine muine ihmeellisyyksineen. Näitä kuitenkin tarvitaan, koska Windows on moniajava käyttöjärjestelmä. Pienellä vaivalla edellä mainitut asiat saa kuitenkin hyvinkin läpinäkyväksi itselleen, eikä niistä tarvitse ainakaan alussa hirveämmin välittää. Useimmat pelikoodaajat tarvitsevat ikkunalleen vain pienimuotoisen viestinkäsittelyn ja tuskin koskaan WIN32 APIn hankalampia osia. Ensimmäinen huomattava ero DOS:iin tehtyyn C/C++-ohjelmaan verrattuna Windows-ohjelmassa on main()-funktion puuttuminen. Se on korvattu Windowsin omalla WinMain() -funktiolla:

1
2
3
4
INT WINAPI WinMain( HINSTANCE hInstance,

                    HINSTANCE hPreviousInstance,

                    LPSTR     lpCmdLine,

                    INT       nCmdShow );

Kuten näkyy, WinMain -funktio eroaa tavallisesta main-funktiosta suhteellisen paljon. Ainoastaan lpCmdLine voi näyttää tutummalta. Kyseessä onkin vanhan tutun argv, argc -parin Windows-vastine. Se sisältää ohjelmaa käynnistäessä annetut komentokehoteparametrit. HINSTANCE-muuttujat saavat nimensä Instance Handle -sanaparista. Handle (suomeksi kahva) on nimensä mukaisesti kiinnityskohta ohjelman ilmentymään (engl. instance) Windowsissa. Windowsin täytyy tietää koko ajan mitä ohjelmia on käytössä, joten Windows luo muistiin ilmentymän ohjelmasta ja seuraa sen avulla ohjelman toimintaa. hInstance on kahva nykyiseen ilmentymään, eli käynnissä olevaan ohjelmaan. Win32 -ohjelmissa hPreviousInstance on kahva ohjelman edelliseen ilmentymään ja on aina arvoltaan NULL. Viimeinen parametri, nCmdShow, kertoo kuinka ikkuna näkyy ruudulla (esimerkiksi minimoituna tehtäväpalkkiin tai maksimoituna peittäen koko ruudun).
Usein WinMain()-funktiossa aivan ensimmäiseksi luodaan ikkuna. Koska Windows on moniajava käyttöjärjestelmä, se tarkoittaa hieman suurempaa koodimäärää kuin tavallinen main()-funktio veisi. Seuraava koodi esittelee ensimmäisen käyttämämme WinMain()-funktion, viestinkäsittelijä- sekä ikkunanluontifunktioiden prototyypit.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <windows.h>



//

// Funktioiden prototyyppejä

// 



LRESULT CALLBACK ViestienKasittelija( HWND hWnd, UINT Viesti,

        WPARAM wParam, LPARAM lParam );

HRESULT LuoIkkuna( HINSTANCE hInstance, INT nCmdShow ); 



//--------------------------------------------

// Nimi  : WinMain()

// Kuvaus: Ohjelman pääfunktio.

//--------------------------------------------

INT WINAPI WinMain( HINSTANCE hInstance,

                    HINSTANCE hPreviousInstance,

                    LPSTR     lpCmdLine,

                    INT       nCmdShow )

{

    //

    // Luodaan ikkuna

    //

    LuoIkkuna( hInstance, nCmdShow );

    //

    // Mennään silmukkaan kunnes ohjelma halutaan

    // lopettaa.

    //

    MSG viesti;

    while( viesti.message != WM_QUIT ){

        //

        // Kurkistetaan onko saapuneita viestejä.

        //

        if( PeekMessage( &viesti, NULL, 0U, 0U, PM_REMOVE ) ){

            //

            // Jos viesti on saapunut se pitää käsitellä.

            //

            TranslateMessage( &viesti );

            DispatchMessage( &viesti );

        }else{

            //

            // Ei viestejä. Suoritetaan ohjelmaa.

            // 



        }

    }

    //

    // Poistetaan ikkunaluokka muistista.

    //

    UnregisterClass( "IkkunaLuokanNimi", hInstance ); 



    //

    // Palautetaan 0 onnistuneen poistumisen merkiksi.

    //

    return 0;

}

LuoIkkuna()-funktio luo nimensä mukaisesti ohjelman käyttämän ikkunan, ja se esitellään seuraavaksi. Sitä ennen tutustutaan kuitenkin yllä olevan koodin while-silmukkaan. Kyseessä on ensimmäinen osa Windowsin viestienkäsittelystä. Ennen while-silmukkaa luodaan viesti-niminen muuttuja, joka on tyypiltään MSG (lyhennys engl. sanasta Message, viesti). Yllä esittellään nk. idle-silmukka, jossa ohjelmakoodia suoritetaan aina kun viestejä ei käsitellä. Ohjelma on Windowsin näkökulmasta toimeton (eli englanniksi idle) aina, kun viestejä ei käsitellä.

Aivan ensimmäiseksi while-lauseessa tarkistetaan viestin sisältö. Jos viestin arvoksi on saatu WM_QUIT, ohjelman tulee sammuttaa itsensä. Jos viestin arvo on jokin muu kurkataan (engl. peek, kurkistaa) ikkunan viestijonoa ja hankitaan viesti-muuttujaan uusi sisältöPeekMessage()- funktiolla. PeekMessage() ottaa parametreinaan täytettävän viestin osoittimen, tarkistettavan ikkunan kahvan, alimman tarkistettavan viestin arvon, ylimmän tarkistettavan viestin arvon, sekä toiminnon mikä viestille tehdään kun se on tarkistettu. Nyt toisena parametrina on NULL, joka kertoo että haluamme viesti-muuttujaan arvon miltä tahansa ohjelman ikkunalta. Jos laittaisimme siihen alempana olevassa LuoIkkuna()-funktiossa saamamme ikkunan kahvan, tarkistettavaksi saataisiin vain sen ikkunan viestit. Kolmas ja neljäs parametri sallivat viestien suodattamisen, johon ei nyt tarkemmin tutustuta. Viides parametri (PM_REMOVE) ilmoittaa että haluamme poistaa viestin ohjelman viestijonosta sen jälkeen, kun olemme siirtäneet sen viesti-muuttujaan.

Jos PeekMessage()-funktio kertoo että viestejä on saatu, käytämme TranslateMessage()-funktiota kääntämään virtual-key -komennot (ohjelmaan määritellyt erikoisnäppäinkomennot, esim. ctrl+F1) kirjainmuotoiseksi viestiksi. Tämän jälkeen DispatchMessage()-funktio lähettää käännetyn viestin sopivalle viestinkäsittelijäfunktiolle. Nyt teemme funktion, joka varsinaisesti luo ikkunan. Funktio ottaa parametreinaan kahvan ohjelman ilmentymään sekä tiedon ohjelman tilasta (esim. minimoitu).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//--------------------------------------------

// Nimi  : LuoIkkuna()

// Kuvaus: Luo ikkunan. Palauttaa S_OK

//         jos siinä onnistuttiin, FALSE

//         muulloin.

//--------------------------------------------

HRESULT LuoIkkuna( HINSTANCE hInstance,

                   INT nCmdShow )

{

    HWND hWnd;   // WindowHandle, eli kahva ikkunan ilmentymään

    WNDCLASS wc; // Ikkunaluokka

    //

    // Täytetään ikkunaluokan tiedot.

    //

    wc.style       = CS_HREDRAW | CS_VREDRAW;

    wc.lpfnWndProc = ViestienKasittelija;

    wc.cbClsExtra  = 0;

    wc.cbWndExtra  = 0;

    wc.hInstance   = hInstance;

    wc.hIcon       = LoadIcon((HINSTANCE) NULL,IDI_APPLICATION);

    wc.hCursor     = LoadCursor((HINSTANCE) NULL,IDC_ARROW);

    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

    wc.lpszMenuName  = NULL;

    wc.lpszClassName = "IkkunaLuokanNimi";



    //

    // Yritetään rekisteröidä ikkunaluokka.

    //

    if (!RegisterClass(&wc))

        return FALSE; 



    //

    // Palautetaan onnistumisen merkiksi S_OK.

    //

    return S_OK;

}

Tässä kohtaa on syytä pysähtyä hetkeksi ja tarkastella lähemmin mitä saatiin aikaiseksi. Ylläoleva koodi tekee ensin muuttujan wc, joka kuvastaa ikkunaluokkaa. Se siis kertoo Windowsille millaisen ikkunan tulemme piakkoin luomaan. Tarkastellaan wc:n jäsenmuuttujia hieman tarkemmin:

wc.Style:
Style määrittää ikkunaluokan tyylin. Arvot CS_VREDRAW ja CS_HREDRAW kertovat, että haluamme koko ikkunan päivittyvän kun sitä liikutellaan tai kun sen kokoa muutellaan. Tyylimuuttujia on Windowsissa lukematon määrä, ja niihin voi jokainen tutustua omalla ajallaan.

wc.lpfnWndProc
Osoitin ikkunaluokan viestienkäsittelijä-funktioon.

wc.cbClsExtra
Määrittää ikkunaluokan jälkeen varattavien lisätavujen määrän. Useimmiten arvo on 0.

wc.cbWndExtra
Määrittää ikkunan ilmentymän jälkeen varattavien lisätavujen määrän Useimmiten arvo on 0.

wc.hInstance
Kahva ikkunan omistavan ohjelman ilmentymään (HINSTANCE).

wc.hIcon
Kahva ikkunaluokan käyttämään ikoniin. LoadIcon()-funktio lataa nyt Windowsin perusikonin.

wc.hCursor
Kahva ikkunaluokan käyttämään kursoriin. Taas kerran käytetään Windowsin valmiskursoria LoadCursor()-funktion avulla.

wc.hbrBackground
Kahva ikkunaluokaan tausta siveltimeen. Windows käyttää eri kyniä, siveltimiä, fontteja ja paletteja (pen, brush, font ja palette) ikkunoiden piirtelyyn. Tähän aiheeseen ei nyt tarkemmin puututa.  GetStockObject()-funktiolla ladataan vain valmiiksi määritelty väri, tässä tapauksessa valkoinen.

wc.lpszMenuName
Osoitin merkkijonoon joka ilmoittaa ikkunaluokan valikon nimen (valikko täytyy olla resurssina sillä nimellä).

wc.lpszClassName
Ikkunaluokan nimi

Kun sopivat arvot ylläoleviin muuttujiin on asetettu, luokka rekisteröidään Windowsiin RegisterClass()-funktiolla. Jos rekisteröinti onnistuu, voi wc:ssä kuvaamasi ikkunan luoda. Jos ei, on parempi lopettaa ohjelman ajaminen samantien. Ikkunaa ei voi luoda jos sitä ei voi kuvailla.

Lisätään aiemmin esiteltyyn koodiin vielä pari kohtaa, jotka viimeistelevät ikkunan luomisen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
//--------------------------------------------

// Nimi  : LuoIkkuna()

// Kuvaus: Luo ikkunan. Palauttaa S_OK

//         jos siinä onnistuttiin, FALSE

//         muulloin.

//--------------------------------------------

HRESULT LuoIkkuna( HINSTANCE hInstance,

                   INT nCmdShow )

{

    HWND hWnd;   // WindowHandle, eli kahva ikkunan ilmentymään

    WNDCLASS wc; // Ikkunaluokka

    //

    // Täytetään ikkunaluokan tiedot.

    //

    wc.style       = CS_HREDRAW | CS_VREDRAW;

    wc.lpfnWndProc = WndProc;

    wc.cbClsExtra  = 0;

    wc.cbWndExtra  = 0;

    wc.hInstance   = hInstance;

    wc.hIcon       = LoadIcon((HINSTANCE) NULL,IDI_APPLICATION);

    wc.hCursor     = LoadCursor((HINSTANCE) NULL,IDC_ARROW);

    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

    wc.lpszMenuName  = NULL;

    wc.lpszClassName = "IkkunaLuokanNimi";

    //

    // Yritetään rekisteröidä ikkunaluokka.

    //

    if (!RegisterClass(&wc))

        return FALSE;

    //

    // Yritetään luoda ikkuna.

    //

    hWnd = CreateWindow( "IkkunaLuokanNimi",

                         "Esimerkkiohjelma",

                         WS_OVERLAPPEDWINDOW,

                         CW_USEDEFAULT,

                         CW_USEDEFAULT,

                         CW_USEDEFAULT,

                         CW_USEDEFAULT,

                         (HWND)  NULL,

                         (HMENU) NULL,

                         hInstance,

                         (LPVOID) NULL );

    //

    // Jos kahvaa ikkunan ilmentymään ei saada,

    // ikkunan luonti epäonnistui. Palautetaan siis

    // FALSE.

    //

    if( !hWnd )

        return FALSE;



    //

    // Näytetään ikkuna ja päivitetään sen sisältö.

    //

    ShowWindow( hWnd, nCmdShow);

    UpdateWindow( hWnd );



    //

    // Palautetaan onnistumisen merkiksi S_OK.

    //

    return S_OK;

}

Varsinainen ikkuna luodaan CreateWindow() -funktiolla, joka ottaa seuraavat parametrit:

lpClassName
Ikkunaluokan nimi. Tässä käytettävä ikkunaluokka on oltava rekisteröity.

lpWindowName
Ikkunan otsikko. Näkyy luotavan ikkunan vasemmassa yläreunassa, sekä tehtäväpalkissa.

dwStyle
Ikkunan tyyppi. Nyt tyyliksi määritetään WS_OVERLAPPEDWINDOW, joka luo ikkunan jonka kokoa voi muuttaa ja jolla on otsikkorivi jossa on ikkuna-valikko (eli valikko joka ilmaantuu ikkunan ikonia painettaessa).

x
Ikkunan paikka X-akselilla. Nyt käytämme Windowsin perusarvoja.

y
Ikkunan paikka Y-akselilla.

nWidth
Ikkunan leveys.

nHeight
Ikkunan korkeus.

hWndParent
Kahva ikkunan isäntä-ikkunaan. Tämä on nyt NULL, koska luomme vain yhden ikkunan.

hMenu
Kahva ikkunan valikkoon. Valikot luodaan ikkunan resurssi-tiedostoon. Taas kerran arvoksi asetetaan nyt NULL, koska emme tarvitse valikkoa.

hInstance
Kahva ikkunaa käyttävän ohjelman ilmentymään (hInstance).

lpParam
Mahdollinen osoitin ikkunan tarvitsemaan lisätietoon. Tätä käytetään MDI-ikkunoita (Multiple Document Interface, Usean Asiakirjan Liittymä, eli monta ikkunaa yhden ison ikkunan sisällä) käytettäessä, joten se on nyt NULL.

Viestien käsittelyä

Viestien käsittely on yksi Windows-ohjelmoinnin olennaisimpia osia. Windows-ohjelmat joutuvat käsittelemään viestejä aina kun jotakin ohjelman nappia tai muuta osaa painetaan tai muokataan. Viestien avulla selvitetään esimerkiksi vierityspalkkien liikkeet. Ruudulla näkyvän graafisen osan alla on siis todellinen viestien sekamelska, jota ohjelmat tulkitsevat viestienkäsittelyfunktoillaan.

Käsittelijäfunktio

Alla oleva koodi on koko viestienkäsittelyfunktio mitä tässä esimerkissä käytämme. Kaikessa yksinkertaisuudessaan se käsittelee vain ikkunan sulkemisviestin.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//--------------------------------------------

// Nimi  : ViestienKasittelija()

// Kuvaus: Funktio joka käsittelee ikkunan

//         viestit.

//--------------------------------------------

LRESULT CALLBACK ViestienKasittelija(HWND   hWnd,

                                     UINT   Viesti,

                                     WPARAM wParam,

                                     LPARAM lParam)

{

  //

    // Tutkitaan mikä viesti saatiin ja tehdään

    // jotain sen mukaisesti.

    //

    switch ( Viesti ){

       case WM_DESTROY:

          {

              //

              // Tuhoamisviesti. Lähetetään

              // Lopetusviesti ja palautetaan

              // TRUE, eli "viesti käsitelty".

              //

              PostQuitMessage( 0 );

              returnTRUE;

          }

       break;

    }



    //

    // Tuntematon viesti. Annetaan windowsin

    // perusviestinkäsittelijän käsitellä viesti.

    //

    return DefWindowProc( hWnd, Viesti, wParam, lParam );

}

Yllä oleva funktio toimii käytännössä siten, että ensin katsotaan viestit joista ollaan kiinnostuneita. Jos yhtään kiinnostavaa viestiä ei ole saapunut, annetaan Windowsissa valmiina olevan viestinkäsittelijän käsitellä viesti.

Loppusanat

Nyt, kun olet lukenut artikkelin, hallitset pienimuotoisen Windows-sovelluksen tekemisen. Kovin paljoa tätä enempää ei Windows-ohjelmointi osaamista DirectX-ohjelmointiin vaadita. Jotta tiedot kuitenkin painuisivat tarkemmin muistiin on syytä muokkailla annettua esimerkkiohjelmaa. Kuten huomasitkin, kaikissa tapauksissa ei tarkisteta virhetilanteita. Harjoitukseksi jääkin kyseisten tilanteiden etsiminen ja niistä selviytyminen.

Kiitokset Risto Karjalaiselle sekä Jussi Huhtiniemelle avusta artikkelin teossa.

Virkistetään muistia

Oletan, että olet lukenut ykköskurssin grafiikasta ja käyn siksi nämä perusasiat Allegron käyttämisestä vain nopeasti läpi. Jos kaipaat tarkempaa selvitystä, löydät sen artikkelista, 2D-grafiikan alkeet Allegroa käyttäen.

allegro_init();
Tämä funktio alustaa Allegron niin, että se on valmis käytettäväksesi. Muista kutsua tätä ennen kuin käytät muita Allegron funktioita

set_gfx_mode();
Tällä funktiolla asetat grafiikkatilan haluamaksesi.

allegro_exit();
Muista laittaa tämä funktiokutsu ohjelmasi loppuun. Se lopettaa Allegron käytön.

install_keyboard();
Jos haluat käyttää Allegron näppäimistöfunktioita, kutsu tätä funktiota ohjelmasi alussa.

Nuo ovat ne asiat, jotka sinun on ykkösosasta muistettava, muita pohjatietoja et tarvitse. Ja sitten asiaan!

Mitä ovat bitmapit?

Kurssin edellisessä osassa en vielä viitsinyt sekoittaa sinua bitmapeillä, mutta silti tietämättäsi (tai tietoisesti) niitä käytit. Nimittäin aina kun kirjoitit johonkin kohtaan screen käytit yhtä bitmappien erikoistyyppiä, joka esittää näyttöä. Mutta eiköhän selvitetä tämä bitmap-asia nyt alusta alkaen…

Allegrossa oikeastaan kaikkien grafiikkafunktioiden pohjana on BITMAP, joka tarkoittaa bittikarttaa. Oikeastaan sitä voisi ajatella jonkinlaisena piirtopohjana. DirectX:ssä niitä nimitetäänkin pinnoiksi. En halua sinua sekoittaa, mutta toivoin tuon selkeyttävän asiaa. Siis, kun piirrät, piirrät aina jollekin bitmapille, piirtopinnalle.

Voit luoda itse bitmappejä esittelemällä ne ikäänkuin muuttujina seuraavaan tapaan:

BITMAP *kuva;

Siis tuossa esiteltiin kuva-niminen bitmappi. Tai itse asiassa siinä esiteltiin osoitin bitmappiin, jota ei vielä ole olemassa. Tätä osoitinajattelua sinun ei kuitenkaan vielä ole pakko ymmärtää, joten jatka vain eteenpäin. Sen koon ja muut sellaiset asiat voit määritellä kahdella tavalla. Ensimmäinen tapa on luoda kuva create_bitmap-funktiolla, esimerkiksi:

kuva=create_bitmap(320,200);

Siinä siis luotiin kuvapinta, joka on 320 pikseliä leveä ja 200 korkea. Ja jos puhutaan osoittimista, niin nyt kuva-osoitin osoittaa uuteen bitmappiin, joka on olemassa. Mutta kuva esittää nyt siis joka tapauksessa tuota uutta piirtoalustaa.

Toinen tapa on helpompi, koska se tapahtuu kuvan lataamisen yhteydessä itsestään. Puhutaan siitä kuitenkin lisää vähän myöhemmin.

Ja sitten kun et enää tarvitse kuvaa, kutsu funktiota destroy_bitmap, joka poistaa kuvan muistista. Esimerkiksi näin poistaisimme muistista tuon vähän aikaa sitten luodun kuva-bitmapin:

destroy_bitmap(kuva);

Näitä asioita harjoittelemme pian käytännössä. Kyllä ne sitten tulevat paremmin tutuiksi ja toivottavasti myös jokseenkin rutiiniksi.

Syvemmälle paletteihin

Myös paletteja katsoimme pikkuisen ja niiden perusperiaatteen taisinkin jo selittää. Puhuimme niistä RGB-structeista ja laittelimme palettiin värejä. Se oli kuitenkin vielä suhteellisen hankalaa.. Nyt katsomme paletteja hieman tarkemmin ja otamme käyttöön helpompia tapoja käyttää paletteja.

Siis muistathan, että jokainen paletin 256 väristä esitetään RGB-structeissa ilmoittamalla niiden punaisen, vihreän ja sinisen värin komponentit.

Paletti on Allegrossa 256 RGB-structin taulukko, joka on nimeltään PALETTE. Jos siis haluat tehdä uuden paletin, esittelet sen muuttujana seuraavasti:

PALETTE oma_paletti;

Siis tuossa loimme paletin nimeltä oma_paletti.

Silloin, kun viimeksi paleteista puhuimme, täyttelimme itse muutamia värejä palettiin. Paletin voit kuitenkin täyttää helpomminkin, niin, että sinun ei melkein tarvitse edes huomata käyttäväsi paletteja. Nimittäin kuvanlatausfunktio, johon paneudumme seuraavassa kappaleessa ottaa yhtenä syötteenä osoittimen palettiisi ja täyttää sen kuvan väreillä. Mutta siitä lisää seuraavassa kappaleessa. Tässä kakkoskurssissa ei tämän enempää paleteista puhuta, paitsi että seuraavassa kappaleessa tulee aika paljon palettiasiaa, kolmoskurssissa olen ajatellut kertoa sitten vielä muutamia hauskoja palettikikkailuja.

Ladataan kuva

Jees. Alku tähän asti on kaikki ollut oikeastaan johdantoa kuvien lataamiselle. No, onhan noista asioista muutenkin hyötyä, mutta ainakin nyt pääsemme tekemään hauskempia juttuja..

Kuvan, jonka nyt lataamme on oltava 256-värinen BMP- tai PCX-kuva. Lataamme sen omaan bitmappiinsä ja otamme myös kuvan paletin talteen. Tehdään tästä kokonainen ohjelma vaikkakin paloittain.. Nyt se alkaa:

  #include <allegro.h>
  #include <stdio.h>

  int main(void)
  {
	BITMAP *kuva;

No niin.. Siinä tulivat alkujutut, jotka ovat jo varmasti tulleet sinulle tutuiksi ja niiden jälkeen kuva-bitmappimme esittely. Jatketaan..

  	PALETTE paletti;

Ja sitten luotiin paletti nimeltään paletti. Huomaa, että tässä vaiheessa kuvaa ei oikeastaan ole edes olemassa, sille ei ole varattu muistia, eikä paletissa ole mitään tietoja. Niitä ei siis vielä saa käyttää muuten kuin luomalla uusi kuva, minkä teemme tuossa kohtapuolin.

	// Allegron alustukset
	allegro_init();
	install_keyboard();
	set_gfx_mode(GFX_AUTODETECT,640,480,0,0); 

	// Ladataan kuva
	kuva=load_bitmap("kuva.pcx",&paletti);

Siinä tulikin tärkeä rivi. Niin tärkeä, että pysähdytäänpä tähän hetkeksi.

Nimittäin tuo on se funktio, joka lataa kuvan bitmappiin (tässä tapauksessa tuohon minkä nimi on kuva) ja paletin. Funktion palautusarvo on siis BITMAP *, mikä tarkoittaa että se palauttaa kuvan, eikä mitä tahansa kuvaa vaan sen kuvan, jonka nimi on mainittu ensimmäisenä funktion parametrinä lainausmerkeissä (kuva.pcx, voisi olla myös kuva.bmp tai vaikka ihan mikä vaan kunhan se on jotain seuraavista tyypeistä: bmp, pcx, lbm ja tga). Paletin se lataa siihen palettiin, jonka nimi on toisena parametrina. Palettejahan voi esitellä niin monta kuin vain haluaa, mutta vain yhtä kerrallaan käytetään ruudulle piirrettäessä, nimittäin sitä, joka on valittu käytettäväksi paletiksi funktiolla set_palette. Mutta se tulee ohjelmassa seuraavaksi, joten eiköhän jatketa eteenpäin.

	// valitaan käytettävä paletti
	set_palette(paletti);

	// piirretään kuva näytölle
	blit(kuva,screen,0,0,0,0,kuva->w,kuva->h);

Tuosta blit-rivistä sinun ei tarvitse vielä välittää, laitoin sen tuohon, jotta näkisit että kuva on latautunut oikein. Se siis piirtää kuvan ruudulle, mutta puhutaan siitä seuraavassa kappaleessa, joka on kokonaan omistettu juuri tälle funktiolle. Ohjelman lopun pitäisi olla sinulle aika tuttua:

	// odotellaan että joku painaa spacea
	while(!key[KEY_SPACE]){}

	// lopetetaan Allegro
	allegro_exit();

	return(0);
}

Noin, nyt on kuva ladattu ja toivottavasti myös lataamisen toimet ymmärretty. Voinemme siis siirtyä tutkimaan erilaisia tapoja piirtää näitä ladattuja kuvia näytölle.

Länttäillään kuvat ruudulle

Kun olemme ladanneet kuvan tai kuvia, on ne tietenkin piirrettävä ruudulle. Tähän tarkoitukseen Allegro tarjoaa kaksi funktiota, itse voit tietenkin kehitellä niitä lisää.. Mutta pitäydytään nyt vielä Allegron funktioissa.

Yksinkertaisin kuvanruudullepiirtofunktio on blit, joka vain länttää kuvan haluamaasi paikkaan toisessa bitmapissä. Eiköhän siis jätetä jaarittelut väliin ja mennä käytäntöön.

Siis… Blit-funktiolla voit kopioida yhdestä bitmapistä haluamasi kokoisen palan toiseen funktioon. Otetaan esimerkki samantien.

blit(kuva,screen,0,0,100,100,30,30);

Tuossa siis kopioidaan kuva-bitmapista kohdasta 0,0 alkaen 30 pikseliä leveä ja 30 pikseliä korkea palanen screen-bitmappiin eli näytölle kohtaan 100,100. Tulikohan tuo tuosta yhtään selvemmäksi? Toivottavasti, sillä nyt mennään eteenpäin.

Blit-funktio on erityisen käyttökelpoinen, jos halutaan piirtää esimerkiksi isoja nelikulmaisia kuvia, esimerkiksi pelien taustoja. Mutta jos haluamme piirtää pallon tai jonkin muun epämääräisen muotoisen kuvan, jättää blit kuvion ympärille ärsyttävät nelikulmaiset reunat. Mutta onneksi on myös toinen funktio, siitä seuraavassa kappaleessa.

Liikkuvia kuvia, eli spritejä

No niin. Nyt siis olisi tarkoitus tutustua spriteihin. Käytännössä sprite on bitmappi. Ennenmuinoin, silloin kuusnelosten aikaan, spritet olivat jotain aivan erilaista, mutta ei siitä sen enempää. Jos se aika kiinnostaa, varmaan netistä löytyy paljonkin kuusnelosasiaa, ja täälläkin ehkä joskus saatan niistä jutuista kirjoitella.

Siis. Sprite on Allegrossa bitmappi, ei sen kummempaa. Usein spriteihin liitetään myös ajatus siitä, että ne ovat ikäänkuin pelin liikkuvia objekteja. Näin saattaa usein olla, mutta ei suinkaan aina.

Okei, enköhän ole sekoittanut sinua jo aivan tarpeeksi. Unohda kaikki edelläoleva spritehöpinä. Ei vaineskaan, kyllä ne voit muistaa, mutta niillä ei ole käytännön kanssa paljonkaan tekemistä.

Se mitä tässä kappaleessa varsinaisesti haluan selittää, on Allegron toinen bitmapinpiirtofunktio, draw_sprite. Se on muuten aika samanlainen kuin blit, mutta se sisältää läpinäkyvän värin.. Kaikki mikä bitmapissä on piirretty paletin värillä 0 näkyy läpinäkyvänä eli ei näy. Tämä on tosi hyödyllistä esimerkiksi, jos haluamme piirtää toisen kuvan päälle pelaajan ukon tai auton tai raketin tai vaikka mitä.

Ai että mitenkö se tehdään? Helppoa:

draw_sprite(screen,kuva,20,20);

Kas noin. Siinä siis piirrämme bitmapin kuva kokonaan bitmappiin screen, joka sattuu olemaan näyttö, kohtaan 20,20. Tämä on siis yksinkertaisempi funktio ohjelmoijan kannalta kuin blit. Sinun ei tarvitse huolehtia siitä minkä kokoinen bitmappisi on tai minkä kohdan siitä haluat piirtää. Funktio piirtää sen aina kokonaan. Sinun tarvitsee vain kertoa mihin sen haluat piirtää.

Näillä kahdella funktiolla pystyt tekemään vaikka mitä. Lisäksi allegrosta löytyy pari erikoisempaa piirtofunktiota, mutta niistä saat ottaa itse selvää, jos ne kiinnostavat. Lisäksi voit tehdä omia blittisysteemejä, esimerkiksi osittain läpinäkyvä (läpikuultava) blitti on tosi hieno efekti. Kirjoitan varmaan siitä tutoriaalin lähiaikoina.

Nyrkkisääntönä voinemme pitää blitin ja draw_spriten käytössä sitä, että blitillä blittaillaan taustoja ja muita isompia juttuja ja draw_spritellä piirretään peliobjektit kuten pelaaja, vastustaja, pallo… Joo, eiköhän tuo tullut selväksi. Otetaan tehtävä.

Tehtävä: Tee ohjelma, joka lataa kaksi kuvaa ja sitten niistä toisen piirtää taustaksi blit-funktiolla ja toisen sen päälle draw_spritellä. Muistathan käyttää paletin 0-väriä draw_spritellä piirrettävän kuvan taustassa.

Tehtävä

Äskeisessä tehtävässä siis latasit kaksi kuvaa ja piirsit toisen taustaksi ja toisen siihen päälle draw_spritellä. Kuvia et kuitenkaan pystynyt liikuttelemaan. Nyt korjataan se puute ja lisätään tehtävän ohjelmaan liikettä.

Tarkoituksena on siis, että tausta pysyy edelleen paikallaan, mutta pienempää kuvaa, spriteä pystyy liikuttelemaan taustan päällä nuolinäppäimillä.

Mitä tarvitsemme tämän tehtävän suorittamiseen? Ensinnäkin kaksi muuttujaa säilyttämään spriten paikkaa ruudulla. Olkoot ne vaikka x ja y, inttejä tietysti. Toiseksi tarvitsemme tietysti kuvat, ne voi piirtää vaikka Paint Shop Prolla. Ja kolmanneksi tarvitsemme while-silmukan, jonka aikana luetaan näppäimistösyötettä (nuolet) ja liikutellaan kuviota sen mukaan.

Luulisin, että osaat tehdä sen itsekin, joten olkoon se tehtävä. PS. Jos kaikki ei näytä aivan oikealta, älä huolestu sillä seuraavassa kappaleessa tulee ratkaisu taustaongelmaan :).

Korjataan taustaongelma

Kuten ennen tehtävää lupasin, tulee nyt ratkaisu sinua varmaankin pitkään askarruttaneeseen ongelmaan. Eikös vain käynytkin niin, että kun liikutit spriteä, jäi vanha kuva taustakuvaan “kiinni” ja seurauksena oli vain sotkua? Jos näin ei käynyt, olet luultavasti huijannut ja piirtänyt taustankin joka kerta uudestaan. Sehän ei toki ole kiellettyä, mutta paljon hitaampaa. Siksi tässä tulee nyt nopeampi ratkaisu.

Idea on yksinkertainen: Ennen kuin piirrät spriten uuteen paikkaan, piirrä vanhan paikan tausta takaisin ja laita talteen uuden paikan tausta. Okei, ei kuulostanut kauhean yksinkertaista, mutta sitä se on. Katsotaan asiaa kaikessa rauhassa esimerkkiohjelman avulla:

  int main(void)
  {
	BITMAP *tausta; // semmoinen iso kuva jonka päälle piirretään
	BITMAP *sprite;
	BITMAP *spriten_taus; // spriten tausta
	PALETTE pal;

	int x=10;
	int y=50;

         allegro_init();
         install_keyboard();
         set_gfx_mode(GFX_AUTODETECT,320,200,0,0);

	// kuvien lataaminen
         tausta=load_pcx("taus.pcx",&pal);
         set_palette(pal);
         sprite=load_pcx("sprite.pcx",&pal);

	// Ja tässä on nyt sitten sitä uutta asiaa
	spriten_taus=create_bitmap(sprite->w,sprite->h);

Siis. Nyt meillä on bitmappi nimeltään spriten_taus, joka on täsmälleen saman kokoinen kuin sprite. Siihen tallennamme siis spriten taustat. Aluksi otamme taustan talteen kohdasta x,y, johon sprite kohta piirretään.

	blit(tausta,spriten_taus,x,y,0,0,spriten_taus->w,spriten_taus->h);

	draw_sprite(tausta,sprite,x,y);

Tuossa siis kopioimme taustasta talteen sen kohdan, joka kohta jää spriten sotkemaksi ja piirsimme spriten taustabitmappiin. Nyt sitten se piirtosilmukka:

	while(!key[KEY_ESC]){
		blit(spriten_taus,0,0,x,y,spriten_taus->w,spriten_taus->h);

Ensin piirretään tausta takaisin spriten päälle ja sitten luetaan näppäimistöltä uudet x- ja y-koordinaatit.

                if(key[KEY_LEFT]) x--;
                if(key[KEY_RIGHT]) x++;
                if(key[KEY_UP]) y--;
                if(key[KEY_DOWN]) y++;

Siispä nyt meillä on uudet koordinaatit ja otamme taas taustan talteen ja sitten piirrämme spriten..

blit(tausta,spriten_taus,x,y,0,0,spriten_taus->w,spriten_taus->h);

		draw_sprite(tausta,sprite,x,y);

		// Ja koko komeus näytölle
		blit(tausta,screen,0,0,0,0,tausta->w, tausta->h);
    	}

        allegro_exit(0);

	return(0);
    }

Huhhuh… Tuo oli raskasta, mutta toivottavasti ei liian vaikeaa. Vielä yksi juttu. Noista kuvista nimittäin. Kun itse tein tämän esimerkin, käytin taustakuvana sellaista kuvaa joka on 320×200 pikselin kokoinen ja spritenä paljon pienempää. Suosittelen samaa myös sinulle. Ja sitten eteenpäin, enää ei ole paljoa jäljellä. Vilkaistaan vielä kaksoispuskurointia ja sitten osaatkin jo vaikka mitä!

Ja sulavuutta kaksoispuskurilla

Jaahas! Nyt olemme päässeet siihen vaiheeseen, että on sopivaa puhua kaksoispuskuroinnista. Kokeile allegron esimerkkiohjelmaa ex8.exe. Siitä saat hyvän kuvan kaksoispuskuroinnin hyödyllisyydestä. Ohjelmassa pallo kulkee ruudun poikki ensin ilman kaksoispuskurointia, niin, että se piirretään suoraan näytölle (screen-bitmappiin). Toisella kerralla se piirretään kaksoispuskurointia käyttäen. Huomaat eron, ilman kaksoispuskurointia kuvan katsominen oli suorastaan sietämätöntä, kaksoispuskuroinnin kanssa jo ihan siedettävää.

Mutta arvaas mitä! Tuo hienous on niin helppoa, että ihan naurattaa.. Sinäkin olet jo käyttänyt kaksoispuskurointia, tietämättäsi. Yllätyitkö? Se oli tuossa edellisessä kappaleessa. Siinä teimme kaikki piirtämiset tausta-bitmapillä ja lopussa vain blittasimme sen näytölle. Kuulostaako tutulta? Eikä todellakaan ole vaikeaa. Kaksoispuskurointi tarkoittaa siis sitä, että mitään ei piirretä suoraan näytölle vaan aina ensin kaksoispuskuriin, joka sitten lopuksi yhdellä nopealla blitillä heitetään näytölle.

Nyt varmaan mietit, että miten tuollaisella pikkujutulla voi olla näin suuri vaikutus. Se johtuu vain siitä, että näyttömuistiin piirtäminen on paljon hitaampaa kuin tavalliseen perusmuistiin. Jos käytämme draw_spriteä screen-bitmapin kanssa on se siis paljon hitaampaa kuin vaikkapa tausta-bitmapillä. Siinä on kaksoispuskuroinnin salaisuus.

Olisikohan nyt pelien aika?

Oho, tämäkin kurssi meni nopeasti. Kirjoitinkin sen oikeastaan yhdessä päivässä – niin, ja korjailin hieman nyt pari vuotta kirjoittamisen jälkeen. Korjauksia joudun varmaan vieläkin tekemään, mutta kaipa tämä on valmis. Pääasia on, että nyt hallitset blittailut ja paljon muuta. Mikään ei enää estä sinua tekemästä ensimmäistä peliäsi. Voit tehdä sen vaikka nyt, mutta muista, älä aloita liian vaikeasta!

Tietenkään sinun ei ole pakko jatkaa peliohjelmoinnin suuntaan vaikka sinne sinua jatkuvasti tyrkinkin (anteeksi siitä..), voit ihan yhtä hyvin tehdä vaikka kuvannäyttelyohjelman tai jotain muuta hyödyllistä.

Joka tapauksessa, valitsit sitten minkä tahansa suunnan tästä eteenpäin, toivotan onnea ja toivon voivani auttaa sinua edelleen!

Jos olet jo lukenut edellisen tutoriaalini, Helposti C-ohjelmoijaksi, tiedät suurin piirtein mitä alkutasoa tällä kurssilla edellytän. En kovin paljoa, perustietämys C-kielestä riittää. Et tarvitse Windows- tai muita erityisohjelmointitaitoja. Kääntäjänä on edelleen DJGPP, jonka kanssa käytetään Allegro-peliohjelmointikirjastoa. Tavoitteena on, että tämän kurssin lopussa osaat piirtää palloja, viivoja, pikseleitä ja muita hauskoja kuvioita. Grafiikkakurssi kakkosessa siirrytään sitten monimutkaisempiin systeemeihin, sukelletaan spriteihin ja tehdään jotain animaatioitakin. Mutta asia kerrallaan.

Mikä Allegro?

Allegrosta en muistaakseni siinä C-kurssissa vielä mitään ehtinyt kertoa. Nyt siis lyhyesti jotain Allegron historiasta ja nykypäivästä sekä siitä miksi sitä kannattaa käyttää.

Allegro on alunperin Shawn Hargreavesin, mutta nykyään suuremman ryhmän kehittämä peliohjelmointikirjasto. Se sisältää todella monia grafiikkafunktioita, äänifunktioita, ohjainlaitteiden hallintafunktioita ja vaikka mitä. Tällä hetkellä siitä on olemassa DOS-versio, ja melkein valmis Windows-versio. Myös X-Windows-versio on työn alla. Näin Allegroa käyttävä peli on helppo siirtää ympäristöstä toiseen. Ja Allegro on ilmainen, samoin kuin DJGPP, vapaaehtoistyönä toteutettu.

Allegron asentamisesta on kerrottu kaikki tarvittava noissa asennusohjeissa, joita löytyy DOS-ohjelmointialueelta. Ja Allegron käytöstä kerrotaan seuraavassa. Erittäin hyvä Allegro-tietolähde on Allegron helppi, jota kannattaa ahkerasti selata. Kun alat tekemään peliä, joka käyttää Allegroa tai jotain sen osaa, ensimmäinen tehtävä on liittää mukaan otsikkotiedosto allegro.h. Se tapahtuu seuraavasti:

#include <allegro.h>

Tuo siis kirjoitetaan ohjelman alkuun muiden includejen jälkeen. Nyt kääntäjä tunnistaa Allegron funktiot osana ohjelmaasi eikä herjaa niistä, mutta vielä on yksi juttu joka on tehtävä. Linkitysvaiheessa tulee ongelmia, jos liballeg.a -tiedostoa ei linkitetä mukaan. Sen voi tehdä kahdella tavalla. Jos käännät ohjelmasi komentoriviltä, käytä seuraavaa lausetta:

gcc foo.c -o foo.exe -lalleg

Siinä foo.c on käännettävä tiedosto, ja -lalleg kertoo linkkerille, että liballeg.a täytyy linkittää mukaan exeen. Jos taas käytät Rhideä, on sinun kirjoitettava Options/Libraries-valikosta löytyvään ikkunaan ensimmäiseen tyhjään kohtaan alleg ja merkittävä sen vieressä oleva ruutu. Esimerkki:

[X] 0 alleg

Nyt järjestelmäsi on valmis käyttämään Allegroa! Joten eiköhän tehdä ensimmäinen Allegro-ohjelma!

Ensimmäinen Allegro-ohjelmasi

No niin. Tässä tulee yksinkertainen ohjelma, joka ei tee paljon mitään, vain sen olennaisimman. Se tekee alustukset, vaihtaa grafiikkatilaa, odottaa, että joku painaa spacea ja sitten lopettaa. Okei, käydään se läpi rivi riviltä.

#include <stdio.h>
#include <allegro.h> // allegron otsikkotiedosto

Kuten varmaan jo huomasitkin, tuossa oli se allegro.h, josta hetki sitten tuolla ylempänä puhuttiin. Ja stdio.h:n varmaan tiedätkin, tässä sitä ei olisi tarvittu, mutta laitan sen aina mukaan varmuuden vuoksi – jos vaikka tekee mieli kirjoittaa tekstiä näytölle.

int main(void)
{

Tuosta alkoi sitten pääohjelma, jossa tällä kertaa tapahtuu kaikki. Peleissä ja muissa isommissa ohjelmissa täytyy aina käyttää aliohjelmia!

 // Ensin alustetaan Allegro
 allegro_init();

Allegro_init on sellainen funktio, joka laittaa Allegron käyttökuntoon. Ennen sitä et voi (saa) käyttää mitään muita Allegron funktioita.

 // Sitten näppäimistö
 install_keyboard();

Install_keyboard ottaa näppäimistön Allegron hallintaan. Tarvitsemme tätä, jotta voimme kohta lukea näppistä.

 // Sitten laitetaan oikea grafiikkatila
 set_gfx_mode(GFX_VGA,320,200,0,0);

Tämä on tärkeä rivi erityisesti tässä kurssissa, koska se on ainoa funktiokutsu tässä ohjelmassa, joka jotenkin liittyy grafiikkaan. Se on grafiikkatilan vaihto. Selitän tarkemmin… Eli ensin on tuo GFX_VGA, joka tarkoittaa, että halutaan käyttää VGA-grafiikkaa. Siihen voisi myös laittaa GFX_AUTODETECT tai GFX_VESA tai jotain muuta sellaista. Sitten on numeroita, 320,200 tarkoittaa, että haluamme resoluution 320×200. Ja lopussa olevien kahden nollan kannattaa aina olla nollia (ainakin yleensä).

 // Odotellaan näppäimen paimallusta
 while(!key[KEY_SPACE]){}

Tässä siis käytetään näppäimistöä. Loopataan While-silmukassa niin kauan kunnes joku painaa SPACEa (KEY_SPACE). Tästä ei tämän enempää, koska tämähän on grafiikkakurssi, ei näppäimistökurssi.

 // Lopetetaan Allegro
 allegro_exit();

Ja jokainen Allegro-ohjelma tulee lopettaa ylläolevaan riviin allegro_exit();, joka lopettaa Allegron ja palauttaa asetukset sellaisiksi kuin ne olivat ennen allegro_init();-kutsua.

 return(0);
}

Ja tähän ohjelma päättyi. Se oli ensimmäinen Allegro-ohjelma. Kokeile sitä ja yritä saada se käännettyä. Kun ymmärrät miten se toimii, voit siirtyä seuraavaan lukuun!

Värit palettiin

Valitsimme tuossa äsken grafiikkatilaksi VGA-tilan 320×200 eli kuten me ohjelmoijat sanomme, tilan 13h :), koska sitä on helpompi käyttää kuin useampivärisiä tiloja.. Nimittäin tässä 13h-tilassa käytettävissämme on vain 256 väriä. Se on kuitenkin enemmän kuin tarpeeksi, ainakin tässä vaiheessa.

Värit on tallennettu palettiin, jossa on nuo 256 väriä tallennettuna. Näitä värejä voit itse muuttaa, valita ne jotka sopivat tarkoitukseesi parhaiten.

Paletin värit on tallennettu RGB-structeihin, jotka ovat muotoa:

typedef struct RGB
{
   unsigned char r, g, b;
} RGB;

Siinä r tarkoittaa värin punaista komponenttia, g vihreää ja b sinistä niinkuin ne on PC:llä tapana esittää. Monet piirto-ohjelmat kuten Paint Shop Pro 5 osaavat ilmaista värit suoraan tässä muodossa. Kokeilemalla nuo värit kuitenkin selviävät. Tässä kuitenkin muutama esimerkkiväri, jotka voit laittaa esimerkiksi ohjelmasi alkuun ja käyttää niitä myöhemmin värien asettamiseen.

   RGB black = { 0,  0,  0  };
   RGB white = { 63, 63, 63 };
   RGB green = { 0,  63, 0  };
   RGB grey  = { 32, 32, 32 };
   RGB red   = { 63, 0,  0  };

Ja PALETTE-tyyppi on 256 RGB-structin taulukko.. Sieltä löytyy siis nuo 256 väriä ylläolevan näköisessä muodossa.

Ennen kuin aletaan piirtämään niin laitetaan muutama väri palettiin. Se tapahtuu allegron funktiolla void set_color(int index, RGB *p);. Siis index on sen värin numero, jota haluamme muuttaa, ja *p osoitin sellaiseen RGB-struktiin, jonka haluamme väriksi sijoittaa. Eiköhän olisi taas esimerkin aika..

// Esimerkki 2: Ohjelma, joka muuttelee värejä..
#include <allegro.h>
#include <stdio.h>

int main(void)
{
  RGB vihrea = { 0, 63, 0 };

  allegro_init();
  install_keyboard();

  set_gfx_mode(GFX_VGA,320,200,0,0);  

  set_color(1,&vihrea);

  while(!key[KEY_ESC]){}

  allegro_exit();

  return(0);
}

Tämä oli muuten aivan samanlainen ohjelma kuin tuo edellinenkin, mutta siinä on yksi uusi funktiokutsu, tuo set_color, josta äsken puhuimmekin.. Se muuttaa tässä siis paletin värin numero 1 vihreäksi..

Tehtävä

Tutki tuota set_color-funktiota! Muuta yllä oleva ohjelma sellaiseksi, että se muuttaa väriä 0, jolloin taustan väri muuttuu. Kokeile erilaisia värejä! Tutki!

Ja pisteitä ruudulle

Äsken muutimme palettia, mutta emme vielä piirtäneet mitään. Niinhän taiteilijatkin tekevät; ensin laitetaan palettiin värit ja sitten vasta aletaan maalaamaan. Katso hetken ajan alla olevaa kuvaa, joka esittää tietokoneen näytön koordinaatistoa.

0,0--------------->n,0
 |
 |
 |
 V
0,n

Siis, Vasemmassa ylänurkassa on piste 0,0 ja x-koordinaatti kasvaa oikealle mennessä. Esimerkiksi resoluutiolla 320×200 oikean ylänurkan koordinaatit ovat 320,0. Vastaavasti y kasvaa alaspäin mentäessä, joten oikea alanurkka on tuolla samalla resoluutiolla 320,200.

Nyt, kun tiedät miten tietokone käsittää koordinaatiston, voitkin piirtää pisteen vaikkapa keskelle ruutua! Mitkä olisivat silloin x- ja y-koordinaatit? (miettimistauko) Nehän olisivat tietystikin 160,100. Jotta voisit piirtää tuon pisteen, tarvitset pisteenpiirtofunktion. Se on nimeltään putpixel. Huom! Pisteitä sanotaan tietokonekielessä pikseleiksi.

putpixel toimii niin, että ensin annetaan pinta, jolle halutaan piirtää pikseli, tässä tapauksessa se saa olla screen, joka tarkoittaa näyttöä, sitten koordinaatit (x ja y) ja lopuksi väri (paletin arvo väliltä 0-255). Esimerkki tulee tässä:

   putpixel(screen,0,0,1);

Tuo siis piirtää vasempaan ylänurkkaan pikselin, joka on väriä numero 1. Jos liittäisimme tämän tuohon edelliseen ohjelmaamme, olisi väri vihreä. Jos emme ole väriä etukäteen asettaneet, se voi olla ihan mikä vain.

Nyt voitkin kokeilla tehdä ohjelman, joka piirtää pikseleitä, vaikkapa satunnaisesti arvottuun paikkaan. Jaa, mutta tuohan olisikin hyvä tehtävä ennen kuin aletaan piirtämään viivoja!

Toinen tehtävä

Tee ohjelma, joka piirtää pisteen näytöltä arvottuun paikkaan! Satunnaisluvuista puhuimme C-kurssissa, katso sieltä, jos et muista.

Pisteistä eteenpäin

No niin. Pisteet ovat pitemmän päälle aika tylsiä, mutta on tärkeää muistaa, että kaikki mitä tästä eteenpäin teemme perustuu niihin, huomaamme me sitä tai emme. Kuitenkaan ei meidän onneksi tarvitse kuvia piirtää piste kerrallaan vaan voimme käyttää apufunktioita. Tässä kurssissa käsittelemme seuraavat piirtofunktiot:

• putpixel – tämä käytiinkin jo läpi
• line – piirtää viivan
• triangle – kolmio
• rect ja rectfill – nelikulmio
• circle ja circlefill – ympyrä
• floodfill – täyttö

Ja eiköhän käydä heti töihin. Siispä viivanpiirtoon! Viivan piirtämiseen on Allegrossa ainakin 3 erilaista funktiota, joista kaikkein kehittynein on line. Tästä eteenpäin esittelen funktiot siinä muodossa kuin ne esitellään yleensä ohjelmointidokumenteissa, jotta totut lukemaan sellaistakin tekstiä. Siis tässä tulee line-funktio “oikeassa” muodossa esitettynä:

void line(BITMAP *bmp, int x1, int y1, int x2, int y2, int color);

Siitä näemme seuraavat asiat: funktio ei palauta mitään arvoa (alussa void), sen nimi on line, se ottaa syötteikseen osoittimen pintaan, johon piirretään, tässä vaiheessa se on screen, joka siis tarkoittaa näyttöä, int-tyyppiset alku- ja loppukoordinaatit sekä värin numeron, joka on välillä 0-255. Kannattaa opetella tulkitsemaan näitä funktioiden prototyyppejä, koska niiden avulla on aika helppoa ymmärtää uusia funktioitan, esimerkiksi niitä allegron funktioita, joita en tässä kurssissa esittele.
Annan yhden piirtoesimerkin, jonka voit liittää alussa tekemäämme värinvaihto-ohjelmaan.

  line(screen, 5, 5, 56, 100, 1);

Tehdään laatikko

Kokeilepa tehdä funktio, joka piirtää laatikon line-käskyllä. Funktio ottaa syötteenä ylänurkan ja alanurkan koordinaatit ja laatikon värin.

No niin, nyt kun olet tehnyt oman laatikkofunktion, voin kertoa, että Alegrosta löytyy sellainen ihan omasta takaakin:

void rect(BITMAP *bmp, int x1, int y1, int x2, int y2, int color);

Siis, tuo piirtää laatikon pinnalle *bmp (screen) alkaen pisteestä x1,y1 (vasen ylänurkka) ja päättyen pisteeseen x2,y2 (oikea alanurkka). Esimerkki tulee tässä:

rect(screen,3,6,100,107,3);

Tuo siis piirtää laatikon, joka alkaa pisteestä 3,6 ja loppuu pisteeseen 100,107. Väri on 3.
Rectistä on vielä toinen muunnos, rectfill, joka tekee täytetyn laatikon. Sitä käytetään samalla tavalla kuin rect. Se vain toimii hieman eri tavalla. Esimerkki:

rectfill(screen,10,10,50,50,4);

Tuo siis piirsi laatikon pisteestä 10,10 pisteeseen 50,50 ja väritti sen värillä 4.

Ja sitten tehdäänkin jo ensimmäinen kuva

Teepä seuraavaksi ohjelma, joka piirtää punaisen mökin käyttäen laatikko- ja viivafunktioita. Tee myös pari ikkunaa ja ovi. Voit myös keksiä muuta hienoa, vaikkapa ikkunalaudan.

Ja mökin pihallahan voisi olla hyvä olla puita, näyttää kodikkaammalta. Mutta puut eivät ole neliön muotoisia, ainakaan yleensä… Runko ehkä, mutta latvan tulee ehkä olla pyöreä tai kolmion mallinen, jos se on kuusi.

Siispä nyt tarvitaan ympyrän- ja kolmionpiirtotyökalut. Ympyrä piirretään funktiolla:

void circle(BITMAP *bmp, int x, int y, int radius, int color);

Muuten tuon funktion kutsuminen tapahtuu samalla tavalla kuin edellä esiteltyjen, paitsi että koordinaattien (keskipiste) jälkeen on ympytän säde kokonaislukuna. Toinen ympyräfunktio circlefill ottaa samat syötteet kuin circle, mutta piirtää täytetyn ympyrän.
Kolmio piirretään funktiolla:

void triangle(BITMAP *bmp, int x1, y1, x2, y2, x3, y3, int color);

Tuo piirtää täytetyn kolmion, jonka kärkipisteet ovat nuo x1,y1 jne.

Ja jos haluat tehdä puihin vinoja oksia, täytyy ne tehdä viivoilla. Tällöin ne kuitenkin jäävät pelkiksi ääriviivoiksi. Siispä tarvitaan vielä väritysfunktio. Se on seuraavanlainen:

void floodfill(BITMAP *bmp, int x, int y, int color);

Floodfill toimii siten, että annetusta pisteestä x,y niinkauan kunnes osuu seinään, se värittää annetulla värillä. Esimerkiksi, jos haluaisin värittää kuvion, jonka sisällä on piste 10,5 värillä 5, kirjoittaisin seuraavasti:

floodfill(screen,10,5,5);

Nyt noilla tiedoilla voit tehdä puihin niitä vinojakin oksia.

Kirjaimista muodostuu sanoja

Tämä kurssi lähenee loppuaan: osaat jo lähes kaikki grafiikkakäskyt, joita tässä kurssissa käymme läpi, ainoastaan tekstin kirjoittaminen puuttuu.

Eiköhän siis katsota nyt tuota kirjoittamista! Se tapahtuu Allegron funktioilla:

void text_mode(int mode);
void textout(BITMAP *bmp, FONT *f, unsigned char *s, int x, int y, int color);

Siis ensin (ohjelman alussa) määritetään tekstin kirjoitustapa funktiolla text_mode. Jos haluat läpinäkyvän taustan, laita parametriksi jokin negatiivinen luku. Jos taas haluat, että tausta on jotain tiettyä väriä, anna sen värin numero. Siispä kaksi esimerkkiä, yksi kummastakin tapauksesta:

text_mode(-1);

Kirjoitetaan läpinäkyvällä taustalla. Tai:

text_mode(15);

Tekstin taustaväri on nyt sitten väri numero 15 paletista. Mutta joo.. Kun tekstinpiirtotapa on valittu, on aika kirjoittaa. Kirjoittaminen tapahtuu funktiolla textout. Otetaan tähän ensin esimerkki ja sitten sen selitys:

textout(screen,font,"Jee, nyt tulee tekstiä!!",10,150,10);

Siinä siis kirjoitetaan näytölle (screen) Allegron perusfontilla (font) – fontteja voit myös itse tehdä, mutta siitä ehkä jotain joskus myöhemmin. Näytölle siis tulee pisteestä 10,150 oikealle värillä 10 teksti: “Jee, nyt tulee tekstiä!!”.

Kokeile liittää tekstiä vaikka siihen talo-ohjelmaasi.. Esimerkiksi oveen voisi kirjoittaa jonkin nimen.

Yksinkertainen piirto-ohjelma

Enempää piirtofunktioita en tässä kurssissa anna, mutta tehdäänpä pieni piirrustusohjelma, sellainen, jossa nuolilla liikuttamalla pystyy piirtämään. Tehdään ensin yhdessä pohja ja sitten päästän sinut kehittelemään ohjelmaa mieleiseksesi.

Mietitäänpä hetki ohjelman rakennetta:

• Allegron alustukset
• Grafiikkatilan vaihto
• Näppäimistön luku
• Pisteen piirtäminen

Noista 1, 2 ja 4 ovat sellaisia, jotka jo osaat tehdä, joten niihin ei tässä sen kummemmin puututa. Näppäimistöstä kuitenkin pari sanaa.

Idea on siis se, että aina kun painetaan nuolinäppäintä, muutetaan x:n ja y:n arvoja ja piirretään uusi pikseli niiden näyttämään kohtaan. Ja näppäimistön lukeminenhan onnistuu helposti Allegron funktioilla:

  if(key[KEY_LEFT]){
 	x--; // Liikutetaan vasemmalle
        putpixel(screen,x,y,vari);
  }
  if(key[KEY_RIGHT]){
 	x++; // Liikutetaan oikealle
        putpixel(screen,x,y,vari);
  }
  if(key[KEY_UP]){
 	y--; // Liikutetaan ylös
        putpixel(screen,x,y,vari);
  }
  if(key[KEY_DOWN]){
 	x--; // Liikutetaan alas
        putpixel(screen,x,y,vari);
  }

Oikeastaan olisin voinut antaa sinun kehitellä tuonkin systeemin, mutta nyt se on tuossa, joten olkoon. Joka tapauksessa näppäimistöä voi Allegron avulla lukea tuolla tavoin. Kerron tästä muissa kursseissa enemmän, nyt riittää kun osaat käyttää nuolinäppäimiä.

Ja loppu jätetään sitten tehtäväksi. Annan vihjettä sen verran, että muistathan laittaa muuttujille alkuarvot, eli määrittää sen paikan mistä piirtäminen aloitetaan.

Loppukaneetti

Nyt on tämä kurssi loppu ja toivottavasti olet oppinut tässä käsitellyt asiat ja ennenmuuta saanut lisää varmuutta ohjelmointiisi. Tähän ei kuitenkaan missään tapauksessa kannata lopettaa, olemme vasta pääsemässä alkuun). Nimittäin nyt on aika siirtyä kohti Grafiikkakurssi kakkosta ja hienompia grafiikkajuttuja! Siispä, onnittelut kurssin suorittamisesta ja onnea jatkossakin!

Olet nyt siis päättänyt alkaa ohjelmoimaan. Sinua kiinnostavat pelit ja se miten ne tehdään. Haluat päästä esiriipun taakse tai ainakin raottaa sitä nähdäksesi mitä nuo suuret ohjelmoijat oikeastaan tekevät (onko se jotain yliluonnollista? ;-). Siispä toivotan sinut tervetulleeksi tähän suureen seikkailuun, jolle rajat asettaa vain mielikuvituksesi (…ja koneiden tehot, taidot, taiteellisuus… :-). Älä pelkää, jos ongelmia tulee vastaan, ovat ihmiset sitä varten, että he auttavat toisiaan. Silloin vain rohkeasti kirjoitat vaikka minulle osoitteeseen: [sähköposti vaihtunut] tai jonnekin muualle kuten DJGPP:n newsgrouppiin tai Suomipelit.com:in keskustelualueelle.

Nyt kuitenkin asiaan (siis siihen mitä otsikossa lukee)… Miksi ohjelmoisit C:llä? Se on sellainen kysymys, johon ei aivan selvää vastausta löydy, mutta melko hyvin voin sen luultavasti selittää. Ensinnäkin, kaikki nykyaikaiset pelit tehdään C:llä (tai C++:lla, joka on C:n sukuinen ja sen kanssa yhteensopiva kieli). Toiseksi, C-kieli on sellainen, että se tuntuu oikealta ohjelmointikieleltä (toisin kuin Pascal tai Basic), ainakin minusta C:n ohjelmointityyli tuntuu hyvältä. Joo. C on yksinkertaisesti paras, ainakin jos aiot päästä pitkälle. Pascalilla pääsee alkuun, mutta sitten on kuitenkin vaihdettava C:hen, kun alkaa tosissaan ohjelmoida. Suosittelen aloittamaan suoraan C:stä, se on hauskaa eikä ollenkaan niin vaikeaa kuin yleensä annetaan ymmärtää!

DJGPP on DJ Delorien ja kumppaneiden ilmainen C-kääntäjä. Se siis tarkoittaa, että sinun ei tarvitse maksaa satoja tai tuhansia markkoja saadaksesi hyvän kääntäjän. Sellainen on saatavilla aivan ilmaiseksi. Jopa Quake on tehty DJGPP:llä. Kaiken lisäksi DJGPP on erittäin tehokas ja hyvä kääntäjä ja sillä on vankka ja yhtenäinen käyttäjäkunta ympäri maailmaa, joten tietoa ja apua ei ole vaikea löytää. Ainut puute on se, että DJGPP ei VIELÄ osaa tehdä Windows-ohjelmia, mutta sehän ei meitä haittaa. Ne kun muutenkin ovat niin hankalia. DJGPP-linkkejä ja muuta tietoa löytyy täältä ja muualta netistä. Pysy mukana!

Ensimmäinen ohjelma

Olemme nyt jo niin pitkällä, että pääsemme kopeloimaan konetta (nopeasti – eikö?), teemme ensimmäisen C-ohjelman ja käännämme sen.

Kautta aikojen ovat C-ohjelmoijat (myös ne jotka nykyään tekevät Quakeja sun muita huippupelejä) aloittaneet uransa seuraavan ohjelman eri variaatioilla, joista luultavasti tämä perusversio on tavallisin. Eli, tässä on koodi, selitän sen myöhemmin.

1
2
3
4
5
6
7
8
/* Ensimmäinen C-ohjelmani */



#include <stdio.h>



int main(void)

{

  printf("Hello World!\n");

}

Nyt kirjoita tuo teksti juuri niin kuin se tuossa on (/* … */- rivin voi jättää pois, se on vain huomautus, eikä kääntäjä välitä siitä). Kirjoittaminen onnistuu aivan tavallisella teksturillakin (esim. DOS:in EDIT), mutta suosittelen Rhideä, joka tekee ohjelmoinnin paljon mukavammaksi. Rhide on Robert Höhnen tekemä (ilmainen) kehitysympäristö DJGPP:lle. Se näyttää käskyt ja numerot yms. eri väreillä ja hoitaa kääntäjän käsittelyn puolestasi. Tallenna sitten ohjelma nimellä hello.c ja käännä se joko komentoriviltä: gcc hello.c -o hello.exe tai Rhidessä: RUN/RUN (valikkoriviltä).

Ja nyt muutama sana tuosta ohjelmasta. Siitä näkyvät C:n perusrakenteet aika hyvin, ei ihme, että siitä lähdetään useimmiten liikkeelle. Äsken mainitsinkin jo ensimmäisellä rivillä olevista /* … */-merkeistä. Ne ovat siis huomautusmerkkejä, jotka kertovat koneelle, että niiden välissä olevaa tekstiä ei pidä kääntää. Niiden väliin voi siis kirjoittaa tietoa muille ohjelmoijille tai itselle muistettavaksi. Se on muuten ihmeellistä kuinka sitä itsekin viikon päästä on aika ulkona, jos ei ole kunnolla selittänyt mitä missäkin tapahtuu. Ei yksinkertaisesti vain muista mitä päässä on sillä hetkellä liikkunut.

Seuraavana onkin include-rivi. Niitä voi ohjelmassa olla enemmänkin, mutta ne ovat aina juuri tuossa ohjelman alussa. C-kieli itsessään ei sisällä paljonkaan erilaisia käskyjä, minkä takia on olemassa standardikirjastot, joissa on eri tyyppisiä käskyjä. Ja kirjastoja käytettäessä täytyy niiden headerit eli otsikkotiedostot liittää ohjelmakoodiin include-lauseilla. Yksi tällainen headeri on stdio.h, joka sisältää tiedon ja tiedostojen käsittelyyn liittyviä funktioiden prototyyppejä (tässä vaiheessa riittää kun ajattelet niitä käskyinä). Elikä, sinun täytyy siis aina ohjelman alussa valita mitä headereita otat mukaan (mitä kirjastoja käytät, vaikkakaan kaikki headerit eivät liity mihinkään kirjastoon) sen mukaan mitä käskyjä haluat käyttää. Voit tietenkin lisätä aina uudentyyppisen käskyn tullessa mukaan sen vaatiman headerin. Headerit liitetään ohjelmaan siis aina #include-lauseella vertailumerkkien <;> välissä (jos se on include-hakemistossa, esim. C:\DJGPP\INCLUDE) tai lainausmerkkejen välissä (” “), jos se on samassa hakemistossa kuin muu lähdekoodi.

int main(void) aloittaa pääohjelman, jollainen täytyy aina C-ohjelmassa olla. Se on toiminnan kannalta korkeimman tason ohjailija, päämies. Se kertoo missä järjestyksessä ohjelma toimii. Myöhemmin kerron myös muista funktioista (aliohjelmista), mutta nyt riittää, että ymmärrät pääohjelman merkityksen (pakollinen, ohjaa toimintaa) ja osaat sellaisen kirjoittaa. Siis… intin tilalla voisi olla myös void tai char (tai unsigned char jne..), mutta ANSI:n standardin mukaan main-funktion täytyy olla muotoa int main(…). Funktion esittelylauseen (int main(void)) jälkeen tulee itse funktio, joka alkaa AINA {-merkillä ja loppuu AINA }-merkkiin. Ja sisennyksiä kannattaa käyttää samalla tavalla kuin mallissa, koska ne selkeyttävät ohjelmaa paljon. Myös tyhjää väliä voi ihan vapaasti laittaa koodia selkeyttämään kunhan muuttujat tai käskyt (yms.) pysyvät kokonaisina.

Ja vielä on yksi rivi. printf(“Hello World!\n”). Siitä nyt vähän selitystä:

printf() itsessään on standardifunktio, jonka käyttämiseen tarvitset otsikkotiedoston stdio.h (siis erittäin tavallinen käsky), joka tulostaa tekstiä ruudulle. “Hello World!\n” on tämä teksti. Mutta \n ei ohjelmaa ajettaessa näy ruudulla, eihän? Se on nimittäin rivinvaihtomerkki. Sen voit lisätä mihin tahansa väliin, mutta muista laittaa se lainausmerkkien väliin.

Erittäin tärkeä on myös lauseen lopussa oleva puolipiste. Jokainen C-kielinen lause lukuunottamatta niitä, jotka esimerkissä ovat puolipisteettömiä, päättyy puolipisteeseen. No niin, nyt olet jo ohjelmoija, osaat tehdä ohjelman, joka kirjoittaa tekstiä ruudulle. Jos et aivan kaikkea tajunnut, kokeilepa muuttaa ohjelmaa ja katso mitä tapahtuu. Kokeile vaikka muuttaa se sellaiseksi, että se kehuu sinua (muistaakseni itse kirjoitutin koneella: “Jarkko Laine, maailman paras ohjelmoija” ;-). Hauskaa, eikö vain.

Muuttujat

Muuttujat ovat ikään kuin pieniä (tai suuria) lokeroita, joihin voi säilöä tietoa ja myöhemmin sen sitten sieltä katsoa. (Näin minulle ainakin joskus asiaa selitettiin…). Käytännössä erittäin suuri osa ohjelmoinnista perustuu muuttujiin. On tärkeää pystyä muuttamaan lukuja ja merkkijonoja kesken ohjelman suorituksen. Eihän esimerkiksi ohjelmasta, joka laskee aina vain yhden ja saman laskun ole paljon hyötyä. Tehdäänpä muuten sellainen. Jos haluat kokeilla
taitojasi, tee se itse ensin katsomatta tästä.

1
2
3
4
5
6
#include <stdio.h>



int main(void)

{

    printf("1 + 1 = %d", 1 + 1);

}

Tällaisesta ohjelmasta ei kuitenkaan ole paljon hyötyä. Tosin esimerkkinä se kylläkin on vallan mainio, tuossakin tuli esille semmoinen tärkeä asia, jota en vielä ole selittänyt. Selitän sen nyt. Printf-lauseeseen voi sijoittaa (muuttuvaa) tietoa myös %d -merkillä. Näitä “prosenttimerkkejä” on muitakin, mutta niistä lisää myöhemmin. Tässä vaiheessa riittää, kun tiedät, että %d tarkoittaa, että sen paikalle laitetaan jokin kokonaisluku (1,2,5,-1…). Lainausmerkkien jälkeen pilkulla erottaen kirjoitetaan tieto, joka %d:n tilalle halutaan. Tässä tapauksessa se on 1+1, mutta useimmiten joku muuttuja. Naitä %d:itä voi olla myös enemmän lauseen sisällä (printf(“luku: %d, toinen luku %d”, 1, 45);).Tämä tulee vielä monta kertaa esille, joten älä huoli jos et tätä täysin vielä käsittänyt.

Muuttujilla siis tarkoitetaan lokeroa, jolla on kuvaava nimi, esim. pisteet. Tällainen muuttuja voisi pelissä pitää sisällään tietoa pelaajan pisteistä. Jos pelaajia on kaksi, tarvitaan taulukkoa, mutta unohda se vielä. Muuttujalla siis täytyy olla nimi, mutta se ei vielä riitä; sillä on myös oltava tyyppi sen mukaan millaista tietoa säilömään sitä käytetään:

int
kokonaislukumuuttuja, ei murto- eikä desimaalilukuja

char
merkkimuuttuja, voi sisältää yhden merkin (esim ‘a’)

float
liukuluku, jos tarvitset desimaalilukuja, tähän niitä saa

double
kaksoistarkkuuden liukuluku, floatti isommalla arvoalueella

Siinä niistä oli perustyypit, joita tulet varmasti tarvitsemaan. Näistä saa sitten erilaisia muunnelmia: esim. unsigned-määritys tekee inteistä ja chareista etumerkittömiä. Luultavasti et näistä tyypeistä kovinkaan monta tarvitse. Int on varmasti yleisin, käytä vain intiä aina kun se on mahdollista. Muitakin toki saa käyttää (enhän minä sitä voi kieltääkään :-). Charia käytät tietenkin sitten merkkitiedon käsittelyyn, esimerkiksi kirjaimiin (tai merkkijonoihin, taulukkoa käyttäen).

Muuttujan tyypin valinta siis riippuu siitä mitä muuttujaan haluaa tallentaa ja ohjelman luonteesta. Hyötyohjelmassa, jossa nopeus ei ole niin tärkeää, voit huoletta käyttää vaikka long doublea jos haluttaa, mutta peleissä nopeus on valttia ja int täten paras vaihtoehto. Merkit tietysti chariin. OK, vielä pari sanaa muuttujien nimistä.

Voisi luulla, että kaikki nimet käyvät, mutta valitettavasti asia ei aivan niin ole, on olemassa muutama (pieni) sääntö. Tunnus (=nimi) ei saa alkaa numerolla ja se saa sisältää kirjaimia (a-z ja A-Z) ja alaviivoja (_) sekä numeroita. Tunnuksen pituus saa olla enintään 32 merkkiä. Nimien kannattaa olla mahdollisimman selkeitä, ei mitään yksikirjaimisia salakoodeja. Skandinaaviset merkit eivät sovi muuttujien nimiin. Ja vielä yksi tärkeä huomautus: isot ja pienet kirjaimet ovat eri asia, eli Kissa on eri muuttuja kuin kissa tai kissA. Näistä ei sitten muuta. Seuraavaksi sijoitusoperaattorit.

Jos tämä teksti on jotenkin sekavaa, se johtuu vain siitä, että yritän tätä kirjoittaessani samalla epätoivoisesti asentaa Internet Explorer nelosta, mikä tahtoo häiritä tähän keskittymistä. Älä välitä, korvaan menetyksen jossain muussa luvussa, sopiiko? … Nyt se lataa, katotaan miten käy. Olen yrittänyt tätä hieman jälkeenpäin selventää (korjata) – toivottavasti onnistuin edes jotenkin :)

Okei, takaisin asiaan. C:ssä on sijoitusoperaattori ‘=’, suomeksi sanottuna: kun haluat laittaa vaikka kokonaislukumuuttujaan numero (int) luvun 10, kirjoitat: numero=10; (ja muistathan puolipisteen!) No niin, nyt pieni tehtävä.

Tehtävä
Mitkä seuraavista kelpaavat muuttujan nimeksi C-kielessä, miksi?

• summa100
• valon_nopeus
• 22_Pistepirkko
• Päiväys
• _xyz
• vasta-aine

Oikea vastaus

summa100, valon_nopeus, _xyz

Eihän ollut vaikeaa? Ja vaikka tehtävä olisi mennytkin väärin niin siitä ainakin opit tuon asian. Eteenpäin!

Varmuuden vuoksi olisi varmaan hyvä katsoa vielä yksi esimerkki ennen kuin mennään eteenpäin. Alussa tekemämme laskuohjelma muuttujia käyttäen, var så god!

1
2
3
4
5
6
7
8
#include <stdio.h>



int main( void )

{

    int vastaus; // esitellään muuttuja

    vastaus = 1 + 1;

    printf(" 1 + 1 = %d ",vastaus);

}

Jos ymmärsit tuon, olet ymmärtänyt muuttujien syvimmän olemuksen! Onneksi olkoon!

Ehtolauseilla muuttujiin eloa

Muuttujistakaan ei yksinään ole paljon hyötyä. Jotta niistä saataisiin kaikki mahdollinen irti, tarvitaan monenlaisia juttuja, joista yksi on nämä ehtolauseet. Ehtolauseita käytetään tutkimaan, onko jokin asia jonkinlainen, eli katsomaan onko muuttujan arvo haluttu ja sitten reagoimaan sen mukaan. Se Explooreri ei ole muuten vieläkään alkanut kunnolla latautua :(.. Joo, tässä on ensin ehtolause-esimerkki paljaalla suomen kielellä:

jos ikä on suurempi kuin 18 niin
	saa ajaa autoa

Ja nyt C:llä:

if (ika > 18) saa_ajaa_autoa();

Huomaatko kuinka C on kaunista, tiivistä ja selkeää? Ensin sana if, joka vastaa suomen sanaa jos, sitten suluissa ehto (ikä on suurempi kuin 18). Huomaa, että C-kielessä ei voi käyttää ääkkösiä, joten ä:stä tulee a. Ja ehdon jälkeen tulee seuraus, joka jos se on vain yksi lause, voidaan kirjoittaa suoraan ehdon perään. Vielä pieni huomio tuosta saa_ajaa_autoa()-lauseesta. Se on funktiokutsu eli sinun ei vielä siitä tarvitse tietää paljon mitään. Kerrottakoon kuitenkin, koska sen kaltaisia lauseita käytetään tässä paljon, että funktion nimen tulee olla kaikkien samojen sääntöjen mukainen kuin muuttujanimien (ei ää- tai öö-kirjaimia, ei välilyöntejä yms.) ja sulut kuuluvat tuohon perään. Usein sulkujen sisään laitetaan muuttujia, nyt niitä ei kuitenkaan tarvita. Jos ehtolauseen seuraus on pitempi, täytyy se koota {}-merkkien väliin ja sisentää kauniisti:

if(a!=10){
  printf("a ei ole 10\n");
}

Siinä oli siis toinen ehtolause-esimerkki, josta näemme, että vertailumerkkejä on monia erilaisia, yksi niistä on tuo !=. Tässä on sellainen luettelo, jossa näet kaikki eri vertailuoperaattorit:

>
suurempi kuin

<
pienempi kuin

>=
suurempi tai yhtäsuuri kuin

<=
pienempi tai yhtäsuuri kuin

==
yhtäsuuri kuin

!=
erisuuri kuin

Siinä tuli näitä vertailuoperaattoreita. Tarkemmat selitykset kaikista operaattoreista löytyy sieltä liitteistä. Mutta hei! Ei se vertailu siihen vielä loppunutkaan, onhan vielä else! Elikä nyt vielä se autonajoehtolause uudestaan:

jos ikä on suurempi kuin 18
   niin saa ajaa autoa
mutta jos ei
   niin ei saa ajaa autoa

Siis uuttahan on tuo jos ei-juttu. Nyt C:llä

if ( ika > 18 ) saa_ajaa_autoa();
else ei_saa_ajaa_autoa();

Se on näin yksinkertaista! Jos if-lauseen ehto ei toteudu (jos ika EI ole suurempi kuin 18), toimitaan else-lauseen mukaan (ei saa ajaa autoa). Tässä siis oli perusehtolause if…then..else. Ja sitten case-lause, jota myöskin saattaa silloin tällöin tarvita.
Ajatellaanpa taas ensin äidinkielellämme:
Tutkitaan ruokalistaa

     jos makkarakeitto: syödään
     jos perunamuusi: kaadetaan maitoa sekaan
     jos maito: juodaan
     jos paperi: ei syödä

Aika tyhjänpäiväinen ruokalistantutkiminen, mutta toivon mukaan se selittää jotenkin tätä asiaa. Siis asiahan on niin, että case-lause (jota tuokin esittää) on vertailulause, joka sisältää eri vaihtoehdot muuttujan eri arvoille. Nyt C:llä

switch ( ruokalista ){
    case makkarakeitto: syodaan();
			break;
    case perunamuusi: maitoa_sekaan();
		      break;
    case maito: juodaan();
		break;
    case paperi: ei_syodak();

    default: break;
}

Niin. Case-lause alkaa jostain syystä switchillä (kaipa sitä switch-lauseeksikin voisi sanoa :-), jonka perään laitetaan sulkuihin tutkittavan muuttujan nimi. Case-kohdissa on sitten muuttujan arvo, jolla tapahtuu jotain ja kaksoispisteen jälkeen toiminto. “Mihin tätä?”, sinä kysyt. Esimerkiksi valikoissa, joissa on erilaisia vaihtoehtoja, tämä on hyödyllinen. Ettei tämä jäisi pelkäksi teoriaksi, otetaan todellinen esimerkki, ohjelma, jota voit kokeilla kääntämällä sen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>



int main(void)

{

    int luku;



    luku=2; // kokeile muuttaa tätä muuttujaa



        clrscr(); // ruuduntyhjennys



    switch (luku)

    {

       case 1 :  printf("ykkönen");

                     break;

           case 2 :  printf("kakkonen");

                     break;

           case 5 :  printf("viitonen");

                     break;

           default:  printf("joku muu..");

                     break;

    }

}

Vielä muutama sana tuosta switch- (tai case-)lause-esimerkistä. Ohjelmassa on ainakin yksi sellainen “käsky”, jota et varmaan aiemmin ole nähnyt: clrscr();. Se on saman näköinen kuin jonkin aikaa sitten näkemämme saa_ajaa_autoa()-funktiot mikä johtuu juuri siitä, että sekin on funktio, joka löytyy standardikirjastosta stdio. Ai niin, olin unohtaa kertoa mitä se tekee. Jos kokeilit ohjelmaa, huomasit varmaan, että ruutu tyhjeni ohjelman alussa. Tämä johtui juuri tästä clrscr();-käskystä (lyhenne sanoista clear screen).

Muuten kaikki onkin varmaan edellisten selitysten pohjalta selvää. Switch:illä aloitetaan ja case kertoo vaihtoehdot ja niiden seuraukset. Jokainen case-pätkä loppuu käskyyn break;. Tulikohan se tuosta selväksi? Toivottavasti :).

Jess! Siinä olivat ehtolauseet, kokeile ja tutki niitä niin kauan kunnes koet hallitsevasi ne ja sitten mennään eteenpäin.

Silmukat, narua ja solmuja?

No niin, nyt ehkä alkaa tämä kirjoitus sujua; explooreri latautuu kauniisti tuolla taustalla ja kello on kymmentä vaille seitsemän aamulla. Tucowsista se lopulta löytyi. Niin, ei kannata suoraan Microsoftilta yrittääkään, se on liian hankalaa. Mutta nyt silmukoihin, ei enää selaintekstiä.

Silmukat ovat sellaisia koodinpätkiä, jotka toistuvat monta kertaa peräkkäin tehden saman asian hieman muuttujien arvoja muutellen uudelleen ja uudelleen. Silmukoita on kolmenlaisia: for-, while- ja do..while -silmukoita. Näitä kaikkia saattaa joissain tapauksissa tarvita. Aloitetaanpa for-silmukasta, joka kuitenkin varmaan on kaikista tavallisin. Ensin suomeksi:

olkoon x aluksi 0,
sitten kierretään niin kauan kuin x on pienempi kuin 10 (x < 10)
ja kasvatetaan joka kierroksella x:ää yhdellä.
tehdään jotain (joka kierroksella)

Anteeksi, mutta minä tässä innostuin eilen tuohon suomenkieliseen ohjelmointiin, en sellaista ollut ennen kokeillutkaan. Vielä tämä loppuun, C:llä:

1
2
3
4
for(x = 0; x < 10; x++ )

{

   tehdaan_jotain();

}

Siis for on silmukan tyyppi. x=0- kohdasssa sijoitetaan äksälle alkuarvo, tässä tapauksessa nolla. Eli, kun silmukka alkaa, on x nolla. x < 10 on vertailu, joka tarkistaa onko aika lopettaa silmukka. Siis, jos tämä ehto ei toteudu – siis x on 10, päättyy silmukka, muuten (niin kauan kuin x < 10) jatketaan ja toimitaan seuraavan kasvatusohjeen mukaan, tässä tapauksessa x++ (kasvatetaan x:ää yhdellä). Ja joka kierroksella tehdään ne asiat, jotka ovat aaltosulkujen {} välissä, esimerkissä se on funktio tehdaan_jotain(); .

Ennen kuin käymme for-silmukan rakennetta tarkemmin läpi haluan kertoa jotain noista C-kielen lyhyistä ja ytimekkäistä kasvatusoperaattoreista.. Jos olet aikaisemmin ohjelmoinut jollain muulla kielellä, on sinulle varmaan tuttua se, että kun haluat kasvattaa vaikka nyt tuota muuttujaa x yhdellä, kirjoitat x=x+1. Järkevää, eikö? Tuo toimii toki myös C:llä, mutta koska kielen kehittäjät ovat pyrkineet mahdollisimman lyhyeen koodiin, suositeltavaa onkin käyttää C-kielelle (ja nykyään myös Javalle) ominaista ++-operaatiota. Katso hetki alla olevaa taulukkoa.

x++
Lisätään x:ään 1

x–
Vähennetään x:ästä 1

x+=5
Lisätään x:ään 5

x-=7
Vähennetään x:ästä 7

Taulukosta vielä. Siis x on int-tyypin muuttuja ja nuo ovat mahdolliset operaatiot mitä sille voi suoraan lyhyesti tehdä. Tästä puhutaan vielä, mm. seuraavassa, eli jatketaan for-silmukan tutkimista: for-silmukan runko selityksin, olkaa hyvä!

for(alustus; jatkuvuusehto; kasvatus)
{
  toiminta;
}

Ensin alustetaan, sitten tutkitaan ja lopuksi kasvatetaan silmukan muuttujaa. Mutta tästä ei vielä ilmene se mihin silmukkaa käytetään: For-lauseen viimeisen sulun jälkeen tulee tuttu {-merkki ja sitten koodi mikä suoritetaan joka kerralla kun silmukka kierretään läpi. Tämä pätkä kannattaa sisentää ja se päättyy }-merkkiin. Tässä taas pieni kaunis esimerkki:

1
2
3
4
5
for(luku=1; luku < 11; luku++)

{

   tulos = 2 * luku;

   printf("%d*2=%d\n", luku, tulos);

}

Jos ymmärsit mitä tuossa tapahtuu, olet uskomattoman hyvä oppimaan, onnitteluni! Jos et ymmärtänyt, ei se haittaa; minä selitän. Tuo on ohjelma, joka laskee kahden kertotaulun (1*2=2, 2*2=4 jne.) ja tulostaa laskut näytölle. Tuonhan olisi toki voinut tehdä toisinkin. Olisi laskenut jokaisen laskun erikseen, mutta se olisi vaatinut paljon enemmän turhaa kirjoittamista. Silmukalla tämä oli paljon helpompi tehdä (Muuten siitä explorerista vielä.. ei se ollutkaan niin yksinkertaista. Se minkä tucowsista kopioin, olikin englanninkielinen versio. Nyt pitäisi löytää suomenkielinen…).

Ensin on for-lause, jossa määritellään silmukka 1:stä 10:een. Nyt varmaan ihmettelet, että miksi siellä sitten on 11 (ai et ihmettele vai? No se on hyvä). Syy on yksinkertainen: haluamme laskea kertolaskun kaikilla luvuilla 1-10. Jos laittaisimme vertailulauseeseen (luku < 11) luvun 10, jäisi kymppi laskuista pois. Kymmenenhän ei ole pienempi kuin kymmenen. Että silleen. Sitten tulee {-merkki ja alkaa silmukan toiminto-osio. Joka kierroksella lasketaan lasku tulos=2*luku;, jossa tulos on jossain aiemmin esitelty int-tyypin muuttuja samoin kuin luku, joka esiintyy myös for-lauseessa. Huomaammekin nyt, että luku on joka kierroksella eri numero: Ensin lasketaan tulos=2*1;, sitten tulos=2*2; jne. Eiköhän se tullut selväksi. Ja koska tiedot täytyy näyttää käyttäjälle, käytämme printf-lausetta, jossa siis %d:n kohdalle tulee muuttujan arvo ja muuttujat ovat lainausmerkkien jäljessä siinä järjestyksessä kuin ne halutaan näyttää.

Jos haluat kokeilla tuota esimerkkiä käytännössä, avaa uusi c-tiedosto, laita sen alkuun tarvittavat includet, tässä tapauksessa stdio.h riittää, ja sitten tuo silmukka main-funktion sisään. Äläkä unohda esitellä muuttujia (ne ovat tyyppiä int).

Siinä oli pieni silmukkaesimerkki. Nyt vielä muutama sana muista silmukkatyypeistä. while-silmukkaa kierretään niin kauan kuin ehto on tosi. Kuulostaa aika samanlaiselta kuin for, eikö. Ainoa ero onkin se.. no katsotaanpa esimerkki: (suomeksi :-)

niin kauan kuin ikä on 7
  käydään ekaa luokkaa

Huomasitkin varmaan sen mitä äsken yritin selittää, eli ainoa ero on se, että ehtoon liittyviä argumentteja (muuttujia tms) ei alusteta missään, eikä mitään kasvateta. Nyt C:llä:

1
2
3
4
while(ika==7)

{

  kaydaan_koulua();

}

Niin. Tämä tyyppi sopii hyvin esimerkiksi peliin, jonka täytyy pyöriä niin kauan kunnes painetaan esciä. Näytän tästä esimerkin (hieman Allegro-koodia käyttäen):

1
2
3
4
while(!key[KEY_ESC])

{

  peli_asiat();

}

Ai että selitystä kaivataan? Joo. Tuo silmukka pyörii siis niin kauan kuin esciä ei paineta. key[KEY_ESC] on Allegron juttu, joka tarkoittaa, että esciä on painettu ja ! on C-kielen operaattori, joka tarkoittaa samaa kuin suomeksi ei.

Tässä vielä pieni esimerkki while-silmukasta:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* Ohjelma, joka laskee kahden kertotaulun

   while-silmukkaa käyttäen */



#include <stdio.h>



int main(void)

{

   int luku, vastaus;



   luku=1;

   vastaus=0;



   while(luku <= 10)

   {

    vastaus = 2 * luku;

    printf("2*%d=%d\n",luku, vastaus);

    luku++;

   }

}

Siinä olivatkin kaikki C-kielen ehtolauseet. Minä lähden kouluun. Tavataan taas tehtävien jälkeen. Moi!

Tehtävä

Tee ohjelma, joka laskee ympyrän alan ja ilmoittaa sen kahden desimaalin tarkkuudella.

Vihje

Kannattaa käyttää kaikissa muuttujissa float-tyyppiä, koska haluamme käyttää desimaalilukuja.

Ympyrän alahan lasketaan kaavalla: Ala=pii*säde², jossa pii on pyöreästi 3.145 tai jotain sellaista.

Jonkin aikaa sitten puhuimme printf-funktion %d-sijoituksista eli siitä, että printf-lauseisiin voi sijoittaa int-tyyppisiä lukuja käyttäen tuota %d-merkkiä. Jos et muista, selaa vähän taaksepäin, sieltä se löytyy..

Myös float-tyyppisiä muuttujia voi tällä tavoin kirjoittaa ruudulle. Silloin ei kuitenkaan käytetä %d:tä vaan %.1f:ää tai jotain sen tapaista.

Siis pisteen jälkeen tulee desimaalien määrä ja sitten f-kirjain. Esimerkiksi, jos haluat kirjoittaa muuttujan a, joka on tyyppiä float, kahden desimaalin tarkkuudella, tapahtuu se seuraavasti:

printf("%.2f",a);

Ratkaisuehdotus

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* Ohjelma, joka laskee ympyrän alan */



#include <stdio.h>



int main(void)

{

   float pii, sade, tulos;



   pii=3.145; // Annetaan piille arvo



   sade=15; // Ympyrän säde



   tulos=pii*sade*sade; // A=pii*r²



   printf("\nYmpyrän ala = pii * %.1f ² = %.2f",sade,tulos);

}

Tehtävä

Tee ohjelma, joka laskee nollasta 20:een ja kertoo onko luku suurempi vai pienempi kuin 10.

Vihje

Käytä muuttujatyyppiä int. Ja for-silmukka voisi myös olla aika kätevä.

Ratkaisuehdotus

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/* Ohjelma joka laskee nollasta kahteen-

   kymmeneen ja kertoo ovatko luvut pienempiä

   vai suurempia kuin 10 */



#include <stdio.h>



int main(void)

{

  int t;



  clrscr(); // tyhjennetään ruutu



  for(t=0; t < 20; t++){

    printf("Luku: %d", t); // tulostetaan luku (t)



    if(t==10) printf(" on 10"); // luku=10 (t)

    else if(t < 10) printf(" on suurempi kuin 10"); // luku > 10

    else printf(" on pienempi kuin 10"); // luku < 10 



    printf("\n"); // rivinvaihto

  }

}

Taulukoita ja merkkijonoja

Joo. Nyt olet jo niin pitkällä, että osaat melkein kaikki C-kielen PERUS-asiat. Se tarkoittaa, että kohta voidaan alkaa puhua jostain mielenkiintoisemmasta. Mutta vielä muutama tärkeä asia sitä ennen. Tässä kappaleessa aloitamme viimeisen etappimme, taulukoin ja merkkijonoin.

Olet varmaankin ihmetellyt ja miettinyt tässä muuttujia katsoessasi, että miten on mahdollisra, että tekstille ei ole kuin char-tyyppinen yhden merkin kokoinen muuttuja, mutta kuitenkin on ohjelmia, joissa säilötään pitempiä sanoja ja jopa lauseita muuttujiin. Monissa muissa kielissä se tehdään omalla string -muuttujatyypillä, mutta sellaistahan C:ssä ei ole. Nyt sinusta varmaan tuntuu, että kiertelen ja kaartelen aivan turhaan. Olet varmaan jo otsikosta arvannut mistä tässä on kyse ja alat ikävystyä, anteeksi :(. Okei, asiaan.

C-kielessä merkkijonot ovat char-tyyppisiä taulukoita. Siispä ensin täytynee perehtyä taulukoihin. Taulukko on muuttujoiden muodostama kokonaisuus, lokerikko (jos muuttuja on lokero :). Se voi olla jono, jolloin puhutaan yksiulotteisesta taulukosta tai kaksi- tai useampiulotteinen taulukko. Kaavio varmaan selventäisi asiaa:

Siinä oli siis pieni kaavio yksiylotteisesta taulukosta, jossa on n solua tai lokeroa tai mieluiten alkiota, niinkuin virallisesti sanotaan. Se alustetaan kuten tavallinen muuttuja, mutta perään laitetaan hakasulkeissa taulukon koko. Esimerkiksi, jos haluamme säilöä viiden pelaajan pistetiedot yhteen taulukkoon (viisisoluinen taulukko), teemme sen seuraavasti:

int pisteet[5];

Taulukko on tyyppiä int, koska pistetiedot ovat useimmiten kokonaislukuja ja viitonen perässä kertoo alkioiden lukumäärän eli taulukon koon. Huomaa, että ensimmäisen alkion numero ei ole 1 vaan 0. Kaksiulotteinen taulukko tehtäisiin vastaavasti:

int monet_pisteet[5][2];

Tuo taulukko voisi näyttää lokerikoksi ajateltuna tältä:

Perään siis vain lisätään toisen ulotteen (ulottuvuuden?) alkioiden määrä. Ja ulotteita (äh, mitä ne nyt on?) voi lisätä niin paljon kuin haluaa – kuitenkaan kovin montaa ei kannata käyttää.

Nyt meillä on yksiulotteinen taulukko pisteet ja haluamme varmaan jo päästä sitä täyttelemään. Teemme näin: Jos haluamme sijoittaa ykköspelaajan pisteet ensimmäiseen alkioon, sijoitamme ne sinne (yksinkertaista ;)

pisteet[0]=52000;

Sinne meni sitten ykköspelaajalle 52000 pistettä. Huomaa edelleen: 0, ei 1. Vastaavasti voisimme antaa viitospelaajalle 10 pistettä:

pisteet[4]=10;

Samaan tapaan voi sitten sijoitella arvoja muillekin pelaajille. Nyt osaat tehdä taulukoita ja kuten jo taisin mainitakin, taulukoita voi tehdä kaiken tyyppisiä (int, float, char…). Ai niin, vielä yksi tärkeä asia. Jos joskus ohjelmasi alkavat antaa ihan ihmeellisiä lukuja, sellaisia joita et varmasti ole taulukkoihisi syöttänyt, on varmaankin kyse ylivuodosta. C nimittäin ei mitenkään vahdi sijoituksiasi, se antaa sinun kaikessa rauhassa sijoittaa 5-alkioisen pistetaulukon alkioon 200, jos niin haluat, mutta laittaa tiedot sitten muualle ja sotkee kaiken. Mitä yritän sanoa on, että huolehdi itse siitä, ettei ohjelmasi sijoittele tietoja olemattomiin alkioihin.

Nyt merkkijonoihin. Selitän tämän nopeasti, koska tämä tosiaankin on erittäin yksinkertainen asia. Tuossa äsken selitin taulukot ja merkkijonot ovat vain niiden yksi muoto. Siispä, jos haluat tallentaa vaikkapa parhaan pelaajan nimen, tarvitset taulukon tyyppiä char:

char paras[10];

Nyt sinulla on kymmenen merkin mittainen merkkijono. Helppoa, eikö? Sijoittaminen siihen ei sen sijaan ole niin helppoa, se ei tapahdu suoraan kuten joissain muissa kielissä vaan stdio-funktiolla strcpy, joka toimii seuraavasti:

strcpy(taulukko,merkkijono);

Taulukko on siis meidän tapauksessamme tuo paras, jonka loimme äsken. Ja merkkijono on tekstiä (tai toinen taulukko), joka halutaan sijoittaa ensimmäiseen merkkijonoon. Esimerkki varmaankin selventää..

strcpy(paras,"Teemu S.");

Tuossa sijoitimme Teemu Selänteen nimen alun merkkijonoon (char-tyypin taulukkoon) paras. Merkkijonon käsittelyyn on myös muita funktioita, mutta selittelen niitä vasta kun tarvitsemme sellaisia. Ei ehkä ihan vielä.
Vähän aikaa sitten puhuimme printf-funktion %d-sijoituksista (int-tyypin muuttujia). Samalla tavalla voit tulostaa myös merkkijonoja käyttäen %s-merkkiä. Tässä täysin toimiva, mutta typerä esimerkki.

1
2
3
4
5
6
7
8
9
#include <stdio.h>



int main(void)

{

  char nimi[10];



  strcpy(nimi,"Jarkko");

  printf("Jarkon nimi on %s",nimi);

}

Lupailin tuossa edellisen kappaleen lopussa interaktiivisuutta, siispä saamanne pitää. Nimittäin stdio-kirjastosta löytyy funktio gets(); jolla voi lukea syötettä näppäimistöltä. Gets-funktiolle annetaan parametrina merkkijono, eli char-tyyppinen taulukko, jonka se sitten täyttää. Ensin pieni esimerkki ja sitten tehtävä.

1
2
3
4
char tekstia[50];



gets(tekstia); // kysyy käyttäjältä syötettä

           // ja tallentaa sen taulukkoon tekstia

Tuo ei ollut vielä kokonainen ohjelma, sellaisen saat tehdä itse seuraavassa tehtävässä.

Tehtävä

Tee ohjelma, joka kysyy käyttäjän nimen ja tervehtii tätä sillä nimellä.

Vihje

Nimelle kannattaa varata tarpeeksi iso merkkijono, esimerkiksi 50 merkkiä.

Ratkaisuehdotus

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* Ohjelma joka kysyy käyttäjän nimen

   ja tervehtii häntä nimeltä */



#include <stdio.h>



int main(void)

{

  char nimi[50];



  printf("Mikä on nimesi? ");



  gets(nimi);



  printf("\nTerve, %s!",nimi);

}

Tehtävä

Seuraavaa tehtävää varten tarvitset vielä yhden tiedon, jota en aiemmin ole pystynyt kertomaan. Nimittäin, kuten varmaan arvasitkin, ei gets-funktiolla voi kysyä kuin merkkijonoja. Niinpä jos halutaan kysyä käyttäjältä kokonaislukuja, täytyy ottaa gets:illä merkkijono ja muuttaa se sitten int:iksi. Se tapahtuu stdlib-funktiolla atoi();, joka ottaa syötteenä merkkijonon ja palauttaa sen inttinä jos mahdollista. Esimerkki ei liene pahitteeksi..

1
2
3
4
5
6
int luku;

char merkkijono[50];



gets(merkkijono);

luku=atoi(merkkijono); // tallentaa muuttujaan luku

                              // merkkijonon sisältämän luvun

Ja nyt sitten se tehtävä!

Tee ohjelma, joka kysyy käyttäjän ikää ja kertoo onko hän tarpeeksi vanha saadakseen äänestää. Vihjeitä en anna tällä kertaa, edellä oleva atoi-juttu saa riittää.

Ratkaisuehdotus

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/* Ohjelma, joka kysyy käyttäjän ikää ja tutkii

   onko hän äänioikeutettu vai ei */



#include <stdio.h>

#include <stdlib.h>



int main(void)

{

  int ika;

  char merkkijono[50];  



  printf("Kuinka vanha olet? ");



  gets(merkkijono); // luetaan syöte



  ika=atoi(merkkijono); // muutetaan se kokonaislukumuotoon



  if(ika < 18) printf("\nEt saa äänestää vielä!\n");

  else printf("\nOlet äänioikeutettu.\n");

}

Funktiot

Jess! Tämä on tosi tärkeä luku. Kaikissa (vähänkin isommissa) ohjelmissa tarvitaan funktioita. Mutta toisaalta tämä on myös hauska luku, koska funktioden oppiminen avaa sinulle aivan uudet mahdollisuudet ohjelmiesi kehittelyyn. Nyt siis tarkkana!

Funktiot eli aliohjelmat ovat ohjelmanpätkiä, jotka suorittavat jonkun tietyn usein tarvittavan pienen (tai isomman) tehtävän. Esimerkiksi luolalentelypelissä yhden funktion tehtävänä voisi olla ruudun vierittäminen, toisen tehtävä olisi törmäysten tutkiminen jne.

Ohjelma siis kannattaa pilkkoa tällaisiin pieniin osiin selkeyden ja käytännöllisyyden takia. Selkeyden siksi, että on paljon helpompi lukea ohjelmakoodia, joka on jaoteltu osiin, samoin kuin tietosanakirjasta jossa on otsikot ja aakkosjärjestys on paljon helpompi etsiäö tietoa kuin täysin järjestämättömästä. Käytännöllisyyden sen takia, että on aika hankalaa ja jopa typerää kirjoittaa sama ohjelmanpätkä joka kerta uudestaan vaikkapa 20 tai 100 kertaa. Se lisää koodin pituutta huomattavasti, mikä on huono asia, jos et yritä saada maailman pisimmän ohjelman ennätystä (mikä on melkoisen vaikeaa sekin – Windows 2000:ssa ohjelmarivejä on 30 miljoonaa, ja Microsoft käyttää funktioita).

Funktioita siis kannattaa käyttää, mutta miten? Tässä tulee vastaus kysymykseesi. Kaikkien taiteen sääntöjen mukaan tulee jokainen funktio esitellä ohjelman alussa heti includejen jälkeen. Itse en tätä vielä vähän aikaa sitten jaksanut tehdä (kääntäjä kyllä kääntää muutenkin..), mutta sitten alkoi tulla ongelmia funktiokutsujen kanssa, kun sen funktion jota kutsutaan piti olla ennen kutsujaa, eikä se tietenkään ollut ja sitten ei sitä löytynyt… Jotenka minä olen sitä mieltä, että tässä kannattaa tehdä ANSI:n mukaan, siis näin:

1.) Ohjelman alkuun #include-rivien jälkeen esittelyt kaikista funktioista

int laske_lasku(int a, int b);
...

2.) Sitten main-funktio (pääohjelma)

3.) Ja sen jälkeen funktiot, samalla tavalla kuin mainikin:

int laske_lasku(int a, int b)
{
    int c; // Tehdään muuttuja laskun avuksi
    c=a+b; // Lasketaan
    return c;  // Palautetaan c
}

Siis, funktion rakenne on samanlainen kuin mainissa, joka sekin on melkein tavallinen funktio. Funktion alussa on rivi, joka alkaa tässä tapauksessa int (voisi olla myös char, float, void…), on esittelyrivi. Alussa ennen mainia on siis aivan sama rivi vain sillä erolla, että siellä alussa se loppuu puolipisteeseen. Se alkaa siis muuttujatyypillä, joka kertoo minkä tyyppisiä palautusarvoja voi funktiolta odottaa. Nyt varmaan odotat minun selittävän mikä palautusarvo on ja senpä taidan tehdäkin. Palautusarvo on luku tms., jonka funktio antaa takaisin kutsujalle return- käskyllä. Sitten tulee funktion nimi, jolla sitä muut funktiot kutsuvat. Ja suluissa kaikki tieto, jota funktiolle annetaan sitä kutsuttaessa. (tässä tapauksessa a ja b). Näitä tietoja voidaan käyttää kuin funktiossa esiteltyjä muuttujia (c=a+b). Näin tehdään siis funktio ja nyt kerron vielä kuinka sitä kutsutaan niin päästään eteenpäin.
Funktiota kutsutaan kirjoittamalla funktion nimi ja suluissa sille annettavat tiedot. Kirjoitetaanpa äsken tehtyä laske_lasku-funktiota kutsuva main-funktio.

1
2
3
4
5
6
int main(void)

{

     int luku; // Luku

     luku=laske_lasku(1,2);

     printf("Tulos: %d",luku);

}

Alussa esitellään muuttuja vastauksen varastoimista varten ja sitten kutsutaan funktiota. Koska se on tyyppiä int ja palauttaa arvon, voimme ottaa palautusarvon muuttujaan (luku=laske…). Jos funktion tyyppi olisi void, tämä ei onnistuisi (ja luultavasti ei olisi tarpeellistakaan). Sitten on funktion nimi ja suluissa arvot muuttujille: ykkönen menee a:han ja kakkonen b:hen. Ja lopuksi kutsutaan stdio-funktiota printf. Muista laittaa alkuun #include <stdio.h>. Nyt siinä taisi tulla tarpeeksi funktioista. Jos jotain puuttuu tästä, jos et tajunnut kaikkea mitä haluaisit, kerro minulle. Lisään sitten tähän lisää tietoa ja vastaan mielelläni kysymyksiisi suoraankin. Huh! Selvittiin tästäkin.

Tyypit, structit ja muuta hauskaa

Niinpä, nyt päästiinkin viimeiseen peruskurssin osaan vai miten sen nyt ilmaisee. Vielä on paljon kerrottavaa, mutta tämän luvun jälkeen voitkin jo valita mihin päin haluat suuntautua, mikä kiinnostaa. Minua kiinnosti ja kiinnostaa edelleen peliohjelmointi, mutta paljon on muitakin mahdollisuuksia. Oppiminenhan jatkuu varmasti yhtä pitkään kuin ohjelmointia harrastaa (ja minä ainakin toivon vielä kahdeksankymppisenä ukkonakin sitä tekeväni), joten matka on pitkä, mutta varmasti kiinnostava. Nyt kuitenkin tämän luvun asioihin.

Tyypit ovat tyyppejä. Siis, yritän selittää tämän jotenkin järkevästi.. No joo, voit siis määrittää omia tyyppejäsi kuten muuttujatyyppejä, vaikkapa näin:

typedef kokonaisluku int;

Siinä yksinkertaisesti luotiin tyyppi nimeltä kokonaisluku, joka käyttäytyy aivan samoin kuin int. Sellaista.. En sano tästä enempää vaan siirryn structeihin, jotka ovat varmasti paljon hyödyllisempiä.

Structeihin voit koota yhteen erilaisia muuttujia helpommin hallittaviksi kokonaisuuksiksi, vähän niinkuin olio-ohjelmoinnissa. Esimerkiksi seuraavalla tavalla voidaan esitellää structi: (niin, tämä samoin kuin tyyppien esittely tehdään funktioiden ulkopuolella, vaikka niiden includejen jälkeen)

1
2
3
4
5
6
7
typedef struct PELAAJA

{

      char nimi[20];

      int pisteet;

      int x;

      int y;

} PELAAJA;

Siinä oli johonkin yksinkertaiseen peliin sopiva pelaajastructi. Se sisältää tilan pelaajan nimelle (20 merkkiä), pistemäärälle ja koordinaateille, riittää hyvin vaikka tämän tutoriaalin esimerkkipeliin. Eli: structin rakenne on seuraava: ensin typedef struct structin nimi ja aaltosulku {. Sitten vain luetellaan kaikki muuttujat, joita siihen halutaan ja loppuun aaltosulku toisin päin ja structin nimi uudestaan.

Kun sitten jossain vaiheessa haluat käyttää structia, esittelet sellaisen, kuten muuttujankin:

PELAAJA pl1;

Siinä tuli PELAAJA-tyyppinen structi nimeltänsä pl1. Nyt pl1:n kaikkiin muuttujiin voi viitata rakenteella: pl1.muuttuja. Selvitelläänpä asiaa täyttämällä pelaajan tiedot:

1
2
3
4
strcpy(pl1.nimi,"Saku Koivu"); // Pelaajan nimi

pl1.pisteet=10000;

pl1.x=10;

pl1.y=10;

Siinä tuli se juttu. Structit olen todennut pelejä ohjelmoidessani tosi hyödyllisiksi, muussa ohjelmoinnissa en niitä ole vielä käyttänyt. Kannattaa käyttää!
Ai niin, lupasin tuossa luvun otsikossa jotain muutakin hauskaa, mitäköhän se voisi olla. No kerronpa vaikka miten satunnaislukuja saa arvottua helposti.

Ensinnäkin tarvitsee includoida time.h ja stdlib.h. Satunnaislukusysteemi alustetaan komennolla srand ja satunnaisluvun saat komennolla rand. Katso vaikka tästä:

srand((unsigned int)time((time_t *)NULL));
luku=(rand()%6)+1;

Jos aiot tehdä seuraavan tehtävän, tarvitset tätä satunnaislukujuttua.

Tehtävä

Tee ohjelma, joka “ajattelee” jotain lukua ja pyytää käyttäjää arvaamaan sitä kunnes arvaa oikein tai liian monta kertaa. Se voisi myös kertoa onko haluttu luku pienempi vai suurempi kuin arvaus

Vihje

Siinä oli kysymys ja tässä sitten hieman apuja. Niin, kyseessä on aivan perusarvailuleikki, ei kovin loisteliasta, mutta varmasti opettavaista. Kirjoita ohjelmasi ja kokeile sitä, käännä se rohkeasti, pelaile ja kehittele vaikka arvauspeli deluxe. Älä ryntää heti katsomaan vastausta vaan katso se vasta lopuksi nähdäksesi mitä tein eri tavalla. Tässä vielä muutama käsky joita tulet siinä tarvitsemaan, ja sitten ei muuta kuin töihin!

gets(merkkijono);
Tällä saat luettua käyttäjältä rivin tekstiä.

luku = atoi(merkkijono);
Ja tällä saat niin paljon merkkijonosta kuin mahdollista muutettua luvuksi

Ratkaisuehdotus

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/* Esimerkki ohjelmasta, joka arvuuttelee lukua

   käyttäjältä



   (C) Jarkko Laine 1999 */



// INCLUDET ///////////////////////////////////////

#include <stdio.h>

#include <stdlib.h>

#include <time.h>



// PROTOTYYPIT ////////////////////////////////////

void nayta_alkutekstit(void);



// PÄÄOHJELMA /////////////////////////////////////

int main(void)

{

   int luku; // oikea luku

   int arvattu; // arvattu luku

   char arvaus[80]; // merkkijono arvausta varten

   int arvaukset=1; // Kuinka monta kertaa pelaaja on arvannut



   nayta_alkutekstit(); // kutsutaan omaa funktiotamme,

                  // joka kirjoittaa tervehdykset



   // Alustetaan satunnaislukugeneraattori

   srand((unsigned int)time((time_t *)NULL));



   // Arvotaan luku

   luku=(rand()%10)+1;



   while(arvattu!=luku){ // Niin kauan kunnes pelaaja arvaa

    printf("\n\nAnnapas tulla arvausta! >");

    gets(arvaus); // kysytään käyttäjältä syöte

    arvattu=atoi(arvaus); // muutetaan se intiksi



    if(arvattu < luku) printf("\nLuku on suurempi...");

    else if(arvattu > luku) printf("\nLuku on pienempi...");

    else printf("\n\nOnneksi olkoon! Käytit vain %d arvausta",arvaukset);



    arvaukset++; // Taas meni yksi arvaus...

   }

}



// funktiomme, joka näyttää alkutekstit

void nayta_alkutekstit(void)

{

   clrscr(); // tyhjennetään ruutu

   printf("Tervetuloa arvauspeliin!\n");

   printf("------------------------\n");

   printf("Tehtäväsi on arvata ajattelemani luku väliltä 1-10\n");

   printf("Onnea!");

}

Siinä se oli… Yksinkertainen, mutta toimiva ohjelma. Funktioitakin käytettiin mallin vuoksi.

Mitä nyt?

Jess! Nyt olet C-guru! Tai et ehkä ihan, mutta tiedät joka tapauksessa niin paljon C-kielestä, että voit jatkaa eteenpäin. Jos olisin oikea opettaja, pitäisin tässä kohdassa kurssikokeen – mutta jääköön se väliin tällä kertaa.

Nyt voit jatkaa mihin suuntaan haluat. Maailma on mahdollisuuksia täynnä. Ja näiltäkin sivuilta löydät mahdollisuuksia vaikka muille jakaa. Ja niitä tulee koko ajan lisää. Tutki ja ohjelmoi! Äläkä epäröi kysyä. Onnea tutkimusmatkallesi! Kuka ties sinusta tulee uusi Bill Gates tai vaikka Jarkko Laine – hehheh :)

Huh! Sainpas sen tehtyä. Vajaa kaksi vuotta siihen meni (taukoineen), mutta nyt se on valmis… Jos löydät virheitä tai epätarkkuuksia, ota yhteyttä sähköpostilla ja kerro minulle. Tai jos sinulla on toiveita siitä minkälaisia kursseja haluat jatkossa nähdä.