1. CS-A1110
  2. Kierros 6
  3. Luku 6.3: Kokoelmia ja madonruokaa

Luku 6.3: Kokoelmia ja madonruokaa

../_images/person09.png

Johdanto

Tämä luku esittelee valikoiman metodeita, joita voi käyttää silmukoiden sijaan tai lisäksi kokoelmia käsitellessä. Metodeille on yhteistä se, että ne löytyvät Scalan valmiilta kokoelmatyypeiltä sekä se, että ne vastaanottavat parametreina funktioita, jotka täsmentävät sitä, mitä kokoelman alkioilla tehdään. Metodit vastaavat muun muassa näihin tarpeisiin:

  • Miten toistan tietyn toimenpiteen kullekin alkiolle kokoelmassa (esim. tulostan sen)?

  • Miten tutkin kokoelman yleisiä ominaisuuksia (esim. ovatko kaikki alkiot tietynlaisia)?

  • Miten valikoin alkioita kokoelmasta (esim. kaikki alkiot, jotka ovat tietynlaisia)?

  • Miten muodostan tuloksen yhdistelemällä kokoelman alkioita (esim. lukujen neliöiden summa tai kuvia päällekkäin sijoittamalla saatu yhdistelmä)?

  • Miten muodostan toisen alkiokokoelma, jonka kukin alkio saadaan tietyllä "kaavalla" alkuperäisestä kokoelmasta (esim. henkilöolioiden luettelosta henkilötunnusten luettelo)?

Näiden korkeamman asteen metodien käyttö on usein kätevää; niitä käyttäen kirjoitettu koodi on usein lyhyttä ja selkeää. Esitellyt metodit ovat erityisen ominaisia funktionaaliselle ohjelmointityylille (mistä lisää luvussa 11.2), kun taas imperatiivisessa ohjelmointitavassa silmukat ovat perinteisesti yleisempiä.

Suuri osa luvusta koostuu pienistä irrallisista esimerkeistä, jotka esittelevät valmiiden metodien käyttöä. Tämä luku on eräänlainen jatko-osa luvulle 4.2, jossa esiteltiin eräitä kokoelmien ensimmäisen asteen metodeita.

Monissa seuraavista esimerkeistä käytetään selkeyden vuoksi kokonaislukuvektoreita. Silti aivan samat metodit toimivat myös muille alkiotyypeille kuin luvuille ja muunlaisille Scala-peruskirjastojen kokoelmille kuin vektoreille.

Esimerkeissä esiintyy paljon funktioliteraaleja — sekä tavallisia että alaviivoin lyhennettyjä — joten varmista, että olet ymmärtänyt edellisen luvun esittelemät merkintätavat.

Toimenpiteen toistaminen alkioille: foreach

Scala-kokoelmille määritellyistä korkeamman asteen metodeista tavallaan yleiskäyttöisin on nimeltään foreach. Koekäytetään sitä vektorin sisältämien lukujen neliöiden tulostamiseen.

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.foreach( n => println(n * n) )100
25
16
25
400

foreach-metodille annetaan parametriksi funktio, jolle kelpaa parametriksi kokoelman alkioiden tyyppinen arvo (tässä Int). Esimerkiksi tässä määritelty funktioliteraali siis on sopiva.

foreach nimensä mukaisesti suorittaa parametriksi annetun funktion kertaalleen kullekin kokoelman sisältämälle alkiolle. Tässä tapauksessa kustakin alkiosta lasketaan toinen potenssi ja tulostetaan se.

Vaikka metodin nimi tulee kahdesta englannin kielen sanasta — for each — niin siinä ei poikkeuksellisesti ole isoa E-kirjainta.

Lienet jo huomannut, että foreach on toiminnaltaan samankaltainen kuin luvussa 6.1 laatimasi repeatForEachElement-funktio. foreach eroaa tuosta aiemmasta funktiosta ennen muuta olemalla kokoelmaolioille valmiiksi määritelty metodi, jota voit käyttää missä vain Scala-ohjelmassa.

Koska foreach-metodille annetaan parametriksi arvoa palauttamaton funktio, niin sitä käytetään parametrifunktion aiheuttamien vaikutuksien vuoksi. Jotta metodikutsu olisi hyödyllinen, on parametrifunktion esimerkiksi tulostettava jotain (kuten yllä) tai vaikutettava jonkin olion tilaan.

Silmukat vs. kokoelmien metodit

Kuten yllä mainittiin, tässä luvussa käsiteltävillä metodeilla voi tehdä samanlaisia asioita kuin silmukoilla. Tämä korostuu erityisesti ensimmäisessä esimerkissämme eli foreach-metodissa. Voidaanhan kirjoittaa myös:

for n <- luvut do
  println(n * n)

Tosiaan, nämä kaksi tekevät keskenään ihan saman:

for alkio <- alkioita do
  Tee jotain alkiolla.
alkioita.foreach( alkio => Tee jotain alkiolla. )

Itse asiassa tällainen for-silmukka on vain erilainen tapa merkitä foreach-metodikutsu; Scala-kääntäjä tulkitsee sen metodikutsuksi.

Tässä vielä esimerkki AuctionHouse-luokan metodista, joka toteutettiin siellä näin:

def nextDay() =
  for current <- this.items do
    current.advanceOneDay()

Olisimme voineet kirjoittaa näinkin:

def nextDay() =
  this.items.foreach( _.advanceOneDay() )

Riippuu tilanteesta ja ohjelmoijan mieltymyksistä, kumpi tapa on luontevampi ja selkeämpi.

Kurssin tulevissa esimerkeissä käytetään foreach-metodia varsin usein (mutta for-silmukkaa myös). Voit itse käyttää kumpaa haluat, mutta sivistyneen Scala-ohjelmoijan on syytä tuntea molemmat tavat.

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Välipuhe abstraktiotasoista

Kokoelman ominaisuuksien tutkiminen

exists- ja forall-metodit

exists-metodilla voi kätevästi selvittää, toteutuuko tietty kriteeri minkään alkion osalta:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.exists( _ < 0 )res0: Boolean = true
luvut.exists( _ < -100 )res1: Boolean = false

exists-metodille annetaan parametriksi funktio, joka ottaa parametrikseen kokoelman alkion ja palauttaa totuusarvon, joka kertoo, toteuttaako kyseinen alkio kriteerin. Esimerkiksi tässä välitetään ensin parametriksi funktio, joka kertoo, onko sen parametriarvo negatiivinen.

Esimerkkikokoelmastamme löytyy (ainakin yksi) alkio, joka on negatiivinen. Sieltä ei löydy yhtään alkiota, joka olisi miinus sataa pienempi.

forall-metodi vastaavasti tutkii, päteekö annettu kriteeri kaikille alkioille:

luvut.forall( _ > 0 )res2: Boolean = false
luvut.forall( _ > -100 )res3: Boolean = true

Tässä tutkittiin ensin, ovatko kaikki alkiot positiivisia; eivät ole. Toisella forall-kutsulla selvisi, että kaikki alkiot ovat miinus satasta suurempia.

Pikkutehtäviä: count, exists ja forall

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Päättele esimerkiksi REPLissä kokeilemalla, mitä kokoelmien count-metodi tekee. Kokeile käskyä luvut.count( _ % 2 == 0 ) ja muita vastaavia.

Mikä tai mitkä seuraavista pitävät paikkansa, kun jokuEhto on funktion nimi ja kokoelma on johonkin alkiokokoelmaan viittaava muuttuja? (Oletetaan, että jokuEhto on tyypiltään sopiva kyseisen kokoelman sisällön tutkimiseen.)

Muista, että kokoelma voi sisältää alkioita tai se voi olla tyhjä. Alla kysytään, mitkä väitteistä pitävät aina paikkansa kokoelman koosta riippumatta.

Jos luot tyhjän kokoelman kokeiluja varten, muista kirjoittaa tyyppiparametri. Siis esim. Vector[String]() tai Buffer[Int]() eikä vain Vector() tai Buffer().

Tehtävän jälkimaininki

Miksi tuossa tehtävässä oli muotoiltu koodi näin?

// Versio 1 (toimiva)
kokoelma.forall( !jokuEhto(_) )

Eikö olisi voinut lukea seuraavasti?

// Versio 2 (toimimaton)
kokoelma.forall( !jokuEhto )

Kuten luku 6.2 kertoi, on monia tapoja kirjoittaa funktioliteraaleja. Kuitenkaan tässä tapauksessa Versio 2 ei toimi, koska se ei määrittele mitään funktioliteraalia.

forall-metodille, samoin kuin monille muille kokoelmien metodeille, tulee antaa parametriksi funktio, jota voi soveltaa kuhunkin kokoelman alkioon. Lausekkeen !jokuEhto arvo ei kuitenkaan ole mikään funktio, vaikka jokuEhto-niminen funktio olisikin olemassa.

Jotta saamme tämän käänteisen tapauksen muotoiltua, pitää forall-metodille välittää parametriksi sellainen erikseen määritelty funktio, joka kutsuu jokuEhto-funktiota ja soveltaa negaatio-operaattoria ! saamaansa paluuarvoon. Sen voi tehdä alaviivalla kuten ylempänä tai nuolinotaatiolla kuten tässä:

// Versio 3 (toimiva)
kokoelma.forall( alkio => !jokuEhto(alkio) )

Alkioiden valikoiminen kokoelmasta

find-, filter-, takeWhile- ja dropWhile-metodit

find-metodi etsii ensimmäisen alkion, joka täyttää parametrifunktion määrittelemän kriteerin. Esimerkiksi tässä etsitään ensimmäinen viitosta pienempi luku:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.find( _ < 5 )res4: Option[Int] = Some(4)

Huomaa: find palauttaa Option-arvon, johon on "kääritty" löydetty alkio. Jos haku oli "huti", saadaan None:

luvut.find( _ == 100 )res5: Option[Int] = None

filter-metodi on samansuuntainen kuin find, mutta se palauttaa kokoelman kaikista niistä alkioista, jotka täyttävät kriteerin. Esimerkiksi tässä vektorista löytyy neljä positiivista lukua:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.filter( _ > 0 )res6: Vector[Int] = Vector(10, 5, 4, 5)

Luvussa 4.2 esiteltiin kokoelmien take-metodi, joka palauttaa osakokoelman, jossa on parametriksi annettu lukumäärä alkioita alkuperäisen kokoelman alusta (esim. luvut.take(3)). Tämän metodin korkeamman asteen serkku on takeWhile:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.takeWhile( _ >= 5 )res7: Vector[Int] = Vector(10, 5)

Metodi siis poimi kokoelman alusta peräkkäisiä alkioita kunnes kohdataan sellainen, joka ei täytä parametrin määräämää kriteeriä.

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Pikkutehtäviä: filter vs. filterNot, takeWhile vs. dropWhile

Päättele esimerkiksi REPLissä kokeilemalla, mitä kokoelmien filterNot-metodi tekee. Sitä kutsutaan samaan tapaan kuin filter-metodia yllä.

Oletetaan, että on määritelty vektoriin viittaava muuttuja nimeltä kokoelma sekä tehty def-määrittely, joka luo tyypiltään sopivan jokuEhto-nimisen funktion. Mikä tai mitkä seuraavista pitävät paikkansa?

Entä mitä tekee dropWhile-metodi? Sitä kutsutaan samaan tapaan kuin takeWhile-metodia aiemmissa esimerkeissä.

Tehtävä: Election-ratkaisua uusiksi (osa 1/2)

[Tämä] tehtävä oli kyllä hyvä, lyhenipä koodi kummasti.

Luvussa 5.6 toteutit metodeita Election-moduulin District-luokkaan. (Jos et toteuttanut, tee se nyt tai ota esiin sen tehtävän esimerkkiratkaisu.) Silloin käytit silmukoita.

Toteuta metodeista nyt kaksi uusiksi: printCandidates ja candidatesFrom. Kumpaankin löytyy yksinkertainen ratkaisu käyttämällä jotakin yllä esitellyistä metodeista. Käytä niitä metodirungoissa for-silmukoiden sijaan.

Palaamme District-luokan muihin metodeihin vielä.

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Alkioiden kuvaaminen toisiksi: map- ja flatMap-metodit

Eräs erittäin usein hyödyllinen toimenpide on alkiokokoelman kuvaaminen eli "mäppäys" toiseksi alkiokokoelmaksi.

map-metodi palauttaa uuden kokoelman, jonka kukin alkio on saatu soveltamalla parametrifunktiota alkuperäisen kokoelman alkioon. Ensimmäisessä esimerkissämme map-käsky laskee kustakin vektorin alkiosta itseisarvon ja palauttaa uuden vektorin, jossa itseisarvot ovat alkuperäisiä alkioita vastaavassa järjestyksessä:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
luvut.map( _.abs )res8: Vector[Int] = Vector(10, 5, 4, 5, 20)

Seuraava map-käsky puolestaan selvittää kustakin alkiosta, onko se vähintään viisi. Tulosvektorissa ovat järjestyksessä näin saadut totuusarvot:

luvut.map( _ >= 5 )res9: Vector[Boolean] = Vector(true, true, false, true, false)

map-metodilla voi kohdistaa mitä moninaisimpia muutosfunktioita useaan alkioon kerralla. Kuten muutkin tämän luvun esittelemät metodit, se löytyy myös muilta alkiokokoelmilta kuin vektoreilta. Esimerkiksi 1 to 10 -lausekkeen arvoksi syntyvä Range-olio (luku 5.6) on kokoelma:

(1 to 10).map( n => n * n )res10: IndexedSeq[Int] = Vector(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

Tässä vielä yksi esimerkki, jossa alkioina on Double-arvoja ja käytämme nimettyä funktiota:

import scala.math.sqrtval data = Vector(100.0, 25.0, 12.3, 2, 1.21)data: Vector[Double] = Vector(100.0, 25.0, 12.3, 2.0, 1.21)
data.map(sqrt)res11: Vector[Double] = Vector(10.0, 5.0, 3.5071355833500366, 1.4142135623730951, 1.1)

Neliöjuurifunktion soveltaminen kuhunkin alkioon tuottaa kokoelman, jossa on alkuperäisten lukujen neliöjuuret.

Pieniä map-tehtäviä

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Tavoitteena on tulostaa riveittäin raportit vektorin sisältämien lukujen neliöistä. Alla on foreach-kutsu ja map-kutsu. Vertaa niitä:

val lukuja = Vector(10, -5, 20)lukuja: Vector[Int] = Vector(10, -5, 20)
lukuja.foreach( luku => println("Neliö on " + luku * luku) )Neliö on 100
Neliö on 25
Neliö on 400
lukuja.map( luku => println("Neliö on " + luku * luku) )Neliö on 100
Neliö on 25
Neliö on 400
res12: Vector[Unit] = Vector((), (), ())

Päättele tai arvaa, mitkä seuraavista tuota esimerkkiä koskevista väitteistä pitävät paikkansa. Lue saamasi palaute.

Tavoitteena on saada vektori, jossa on alkuperäisen vektorin sisältämien lukujen neliöt. Alla on foreach-kutsu ja map-kutsu. Vertaa niitä:

lukuja.foreach( luku => luku * luku )lukuja.map( luku => luku * luku )res13: Vector[Int] = Vector(100, 25, 400)

Arvioi tuota koodia koskevat väitteet.

Oletetaan, että muuttuja puskuri on alustettu osoittamaan Buffer[Int]-tyyppiseen kokoelmaan eli kokonaislukuja sisältävään "yksiulotteiseen" puskuriin. Oletetaan myös, että tuossa puskurissa on ainakin yksi alkio.

Mitä tapahtuu, kun evaluoidaan puskuri.map( x => Buffer(x, x + 1) )? Tutki itse REPLissä tarpeen mukaan.

flatMap-metodi

Luvussa 6.1 näyttäytyi metodi flatten, joka "litistää" kokoelmia sisältävän kokoelman:

val sisakkain = Vector(Vector(3, -10, -4), Vector(5, -10, 1), Vector(-1), Vector(4, 4))sisakkain: Vector[Vector[Int]] = Vector(Vector(3, -10, -4), Vector(5, -10, 1), Vector(-1), Vector(4, 4))
sisakkain.flattenres14: Vector[Int] = Vector(3, -10, -4, 5, -10, 1, -1, 4, 4)

On melko yleistä, että halutaan suorittaa peräkkäin map ja flatten: ensin "mäppäys" ja sitten litistäminen. Tässä pieni kokeiluesimerkki:

val luvut = Vector(10, 5, 4, 5, -20)luvut: Vector[Int] = Vector(10, 5, 4, 5, -20)
val kokeilu = luvut.map( n => Vector(-n.abs, 0, n.abs) )kokeilu: Vector[Vector[Int]] = Vector(Vector(-10, 0, 10), Vector(-5, 0, 5), Vector(-4, 0, 4), Vector(-5, 0, 5),
Vector(-20, 0, 20))
kokeilu.flattenres15: Vector[Int] = Vector(-10, 0, 10, -5, 0, 5, -4, 0, 4, -5, 0, 5, -20, 0, 20)

"Mäppäyksen" ja litistämisen voi yhdistää:

luvut.flatMap( n => Vector(-n.abs, 0, n.abs) )res16: Vector[Int] = Vector(-10, 0, 10, -5, 0, 5, -4, 0, 4, -5, 0, 5, -20, 0, 20)

Käsky kokoelma.flatMap(funktio) siis ajaa saman asian kuin kokoelma.map(funktio).flatten.

Saatat ihmetellä, onko moiselle tosiaan niin paljon tarvetta, että erillisestä flatMap-yhdistelmämetodista on hyötyä. On sille. Metodin hyödyllisyys korostuu, kun ohjelmointikokemuksesi karttuu tämän kurssin aikana ja sen jälkeen.

Esimerkki: käyttäjiä ja osoitteita

Äskeistä hieman kiinnostavampia esimerkkejä map- ja flatMap-metodeista saadaan, kun tarkastelemme seuraavaa pientä luokkaa.

class Kayttaja(val tunnus: String, val mailiosoitteet: Vector[String]):
  override def toString = this.tunnus + " <" + this.mailiosoitteet.mkString(",") + ">"

Oletetaan nyt, että ohjelma käsittelee useita tällaisia käyttäjiä, jotka on tallennettu vektoriin. Seuraavassa esimerkkikoodissa käyttäjäolioita luodaan vain kaksi, mutta niitä voisi olla kuinka paljon tahansa.

val kaikkiKayttajat = Vector(
  Kayttaja("taina", Vector("taina.teekkari@aalto.fi", "taina.teekkari@iki.fi", "taina.teekkari@gmail.com")),
  Kayttaja("megadestroyer", Vector("teemu.teekkari@aalto.fi", "teemuteekkari@gmail.com"))
)kaikkiKayttajat: Vector[Kayttaja] =
Vector(taina <taina.teekkari@aalto.fi,taina.teekkari@iki.fi,taina.teekkari@gmail.com>,
megadestroyer <teemu.teekkari@aalto.fi,teemuteekkari@gmail.com>)

Mitä, jos halutaan selvittää kaikkien vektoriin tallennettujen käyttäjien käyttäjätunnukset? Tai muodostaa vektori, jossa on kaikkien käyttäjien kaikki sähköpostiosoitteet?

Silmukoita voisi tietysti käyttää, mutta mainituilla korkeamman asteen metodeilla homma onnistuu vaivatta.

Kaikkien käyttäjien käyttäjätunnukset saadaan kauniisti map-metodilla, kun parametriksi annetaan funktio, joka "mäppää" olion sen tunnus-ilmentymämuuttujan arvoksi.

kaikkiKayttajat.map( _.tunnus )res17: Vector[String] = Vector(taina, megadestroyer)

Pelkällä map-metodilla saadaan myös sähköpostiosoitteet. Ne tulevat sisäkkäisessä kokoelmassa, mikä ei (tarkoituksesta riippuen) välttämättä ole kätevää:

kaikkiKayttajat.map( _.mailiosoitteet )res18: Vector[Vector[String]] = Vector(Vector(taina.teekkari@aalto.fi, taina.teekkari@iki.fi, taina.teekkari@gmail.com),
Vector(teemu.teekkari@aalto.fi, teemuteekkari@gmail.com))

Käyttämällä mapin sijaan flatMap-metodia saadaan haluttu "litteä" luettelo kaikista kaikkien käyttäjien sähköpostiosoitteista:

kaikkiKayttajat.flatMap( _.mailiosoitteet )res19: Vector[String] = Vector(taina.teekkari@aalto.fi, taina.teekkari@iki.fi, taina.teekkari@gmail.com,
teemu.teekkari@aalto.fi, teemuteekkari@gmail.com)

Seuraava ohjelmointiharjoitus ei käsittele pelkästään äskeisiä kokoelmien metodeita, mutta niillekin löytyy käyttöä.

Tehtävä: matopeli

Matopeli (Snake) on alun perin 1970-lukulainen klassikko, jossa pelaajan ohjaama "mato" tai "käärme" kääntyilee kaksiulotteisella kentällä ja etsii syötävää kasvaakseen. 1990-luvulla se teki näyttävän paluun kännyköihin, millä on viime vuosinakin retroiltu. Tätä lukiessasi peli saattaa jo olla uusioretrokitschiä.

../_images/snake_on_grid_1.png

Matopeli ja sen toimintaa selkiyttävä ruudukko. Vihreä neliö kuvaa madolle seuraavaksi tarjolla olevaa ruokaa; se on ruudussa numero (8,6). Numerointi alkaa vasemman yläkulman ruudusta (0,0); se kuten muutkin reunaruudut näkyvät kuvassa vain osittain. Kuvan mato muodostuu neljästä segmentistä, jotka sijaitsevat ruuduissa (5,4), (4,4), (3,4) ja (3,5).

Ohjelmointiharjoituksenakin matopeli on klassinen. Yhtykäämme perinteeseen.

Matopelin käsitteitä

Matopelin keskeiset osat ovat itse mato sekä ruoka, jota mato etsii. Kullakin hetkellä tarjolla on yksi ruoka jossakin päin pelikenttää. Kun mato syö sen eli madon pää on osumassa ruokaan, mato kasvaa ja pelikentälle ilmestyy uusi ruoka.

Pelialueen voi mieltää ruudukoksi (grid), jossa ruoka sijaitsee tietyssä ruudussa (ks. kuva). Mato koostuu "pätkistä" eli segmenteistä, joista kukin sijoittuu tiettyyn ruutuun.

../_images/snake_on_grid_2.png

Ensimmäinen kuva oli tilanteesta, jossa mato oli ollut matkalla ylös ja kääntynyt oikealle. Tässä toisessa kuvassa mato on liikkunut yhden lisäaskelen edelliseen verrattuna. Madon etupää on siirtynyt ruudun verran oikealle ja "vetänyt perässään" muita kolmea. Ruutu (3,5), jossa madon viimeinen segmentti oli, jäi tyhjäksi.

Pelaajan ainoa toimi on kääntää madon liikkumasuuntaa nuolinäppäimillä. Suuntana voi olla jokin neljästä pääilmansuunnasta.

Pelin edetessä mato liikkuu: sen pää eli etummainen segmentti liikkuu viimeisimpään pelaajan valitsemaan suuntaan ja muut segmentit seuraavat perässä (ks. toinen kuva). Kuitenkin jos madon pää osuu ruokaan, mato syö sen ja kasvaa yhdellä segmentillä: ruoan kohdalle ilmestyy uusi segmentti ja kaikki aiemmat jäävät entiselleen.

Peli päättyy, kun madon pää osuu johonkin muuhun kuin ruokaan.

Snake-ohjelman luokat

Moduulissa Snake on osittainen toteutus matopelille. Sen kokonaisrakenne on samankaltainen kuin tutussa FlappyBug-ohjelmassa: SnakeGame-luokalla mallinnetaan pelitilanteita, ja SnakeApp.scala määrittelee käyttölittymän, joka pistää pelitilanteen näkyviin ja vastaanottaa pelaajan komennot.

Luokan SnakeGame ilmentymä on siis yksi matopelisessio. Tuollainen olio on muuttuvatilainen: sen tila muuttuu, kun sen metodeita kutsutaan. SnakeGame-olio pitää kirjaa

  • seuraavasta tarjolla olevasta ruuasta: missä päin ruudukkoa se on?

  • madon segmenttien sijainneista: missä päin ruudukkoa ne ovat?

  • madon (pään) kulkusuunnasta: mihin neljästä pääsuunnasta se on viimeksi asetettu kulkemaan?

Luokan pitää siis käsitellä sijainteja ruudukolla sekä suuntia. Näihin tarpeisiin löytyy välineitä o1-kirjastostamme:

Apuluokkia: GridPos ja CompassDir

Luokka GridPos sopii kuvaamaan kahdesta kokonaisluvusta koostuvia koordinaatteja ruudukossa.

  • Se on samantapainen kuin tuttu Pos, mutta edustaa nimenomaan ruudukkokoordinaatteja ja tarjoaa siihen tarkoitukseen sopivia metodeita.

  • Näin erotamme toisistaan kaksi seikkaa: sen, missä ruudussa asia on (GridPos), ja sen, mihin pisteeseen tietynkokoisessa kuvassa tuo asia piirretään (Pos).

    • Ruudukkosijainti on osa aihealueen logiikkaa (matopelin sääntöjä). Sijainti kuvassa liittyy vain käyttöliittymään.

    • Vrt. Stars-ohjelma, jossa erotimme toisistaan StarCoords-sijainnin kartalla ja Pos-sijainnin kuvassa.

Luokka CompassDir kuvaa "ilmansuuntia" kuten pohjoinen (eli ylös) tai länsi (eli vasemmalle).

  • Se sopii hyvin madon liikkumasuunnan kirjaamiseen.

  • Se toimii hyvin yhteen GridPos-luokan kanssa. Voimme esimerkiksi kysyä tiettyä GridPos-oliolta, joka vastaa tiettyä koordinaattiparia, mikä sen itäinen naapurikoordinaatti on.

Molempien luokkien Scaladoc-dokumentaatio löytyy O1Library-moduulista.

../_images/module_snake.png

Snake-ohjelmaan liittyvien luokkien väliset yhteydet.

Ensin pari pohjustavaa pikkutehtävää

Näiden parin pikkukysymyksen vastauksista on hyötyä varsinaisessa matopelitehtävässä.

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Varsinainen tehtävänanto

Toteuta tiedostoihin SnakeGame.scala ja SnakeApp.scala puuttuviksi merkityt kohdat. Suosittelemme seuraavaa järjestystä.

Vaihe 0/5: valmistelut

Aja annettu ohjelma. Esiin tulee pelimaailma, jossa on ruoka ja yhden segmentin mittainen matonen. (Yllä oleviin kuviin lisäksi piirretyn ruudukon ei ole tarkoituskaan näkyä.) Mato ei vielä liiku.

Tutustu SnakeGame-luokkaan. Paikanna puuttuvat osat. Katso, miten annettu koodi käyttää GridPos- ja CompassDir-luokkia. Lue noiden luokkien Scaladoc-dokumentaatiosta ainakin alun johdannot; kaikkia metodeita ei ole tarpeen opetella. (Itse Snake-moduulista ei ole scaladoceja, vaan tarvittavat tiedot on annettu tässä luvussa ja koodissa.)

Voit silmäillä käyttöliittymääkin. Se on laadittu kutsumaan kellon tikittäessä SnakeGame-olion advance-metodia. Tuon metodin jonka pitäisi liikuttaa matoa. Annettu versio metodista ei kuitenkaan tee mitään.

Vaihe 1/5: mato liikkeelle

Toteuta advance ensin osittaisena: laita se siirtämään madon pää viereiseen ruutuun. Älä vielä välitä madon kasvattamisesta tai ruoan sijainnista.

Vinkkejä:

  • segments-muuttuja osoittaa yksialkioiseen vektoriin, jossa on madon (pään) sijainti. Kyseessä on var-muuttuja: korvaa entinen vektori uudella, jossa on vanhan sijainnin naapuri kulkusuunnassa.

  • Naapurin saa kätevästi GridPos-luokan metodilla.

Aja muokattu ohjelma. Yksisegmenttisen madon pitäisi nyt vipeltää ruudulla. Peli päättyy sen törmätessä pelialueen reunaan. Nuolinäppäimet (tai WASD-näppäimet) ohjaavat matoa. Mato menee läpi ruoista niitä nauttimatta.

Vaihe 2/5: ruoka

Kehitä advance-metodia edelleen. Metodin on nyt lisäksi arvottava ruoalle uusi sijainti aina kun mato osuu ruokaan. Tämä tapahtuu osana samaa liikettä (eli osana samaa advance-kutsua), joka siirtää madon ainoan segmentin ruoan kohdalle. Metodi siis ensin siirtää matoa ja sitten ruokaa; näistä jälkimmäinen tehdään vain madon päätyessä ruoan kohdalle.

Tämä käy vaihtamalla pelin nextFood-muuttujan arvoa. Tarjolla on metodi randomEmptyLocation(), jolla voit arpoa uuden sijainnin. (Se on SnakeGamen metodi. Metodin toteutusta ei tarvitse ymmärtää; riittää kun kutsut sitä ja käytät sen palauttamaa GridPos-arvoa.)

Pelin nopeus on määritelty käyttöliittymän vakiossa GameSpeed. Voit säätää sitä mielesi mukaan. Jos peliä testatessasi vaihdat nopeudeksi esimerkiksi 1, niin aika matelee hyvin hitaasti.

Vaihe 3/5: kasvu

Laitetaan mato kasvamaan. Huomaa kuitenkin, että tässä vaiheessa muokkaat vasta ohjelman sisäistä mallia madon tilasta — et vielä käyttöliittymää. Kasvu ei siis vielä näy ruudulla, joten älä ihmettele, jos et nyt saa näkyvää muutosta peliin.

Viimeistele advance-metodi. Metodin tulee joka kutsukerralla joko kasvattaa tai liikuttaa matoa, muttei molempia näistä. Tapauksia on kaksi: kun pää on osumaisillaan ruokaan, mato syö ja siihen lisätään segmentti; muussa tapauksessa mato etenee saman kokoisena kuin ennenkin.

Edellisessä vaiheessa oletettiin, että segments-muuttujan osoittamassa vektorissa on aina tasan yksi alkio. Nyt tämä oletus ei enää päde.

Yllä vaiheessa 1 kirjoitit koodirivin, joka päivittää segments-muuttujan arvoksi uuden yksialkioisen vektorin. Poista tuo käsky. Kirjoita sen tilalle uutta koodia, joka käsittelee kummankin tapauksista: ruokaan osuttiin tai ei osuttu.

Toisin sanoen: korvaa segments-muuttujan vanha arvo uudella vektorilla, jossa on kaikki madon segmenttien uudet sijainnit. Segmenttejä tulisi olla askelen jälkeen joko yhtä monta kuin ennen tai yksi enemmän.

Ohjeita ja vinkkejä:

../_images/snake_on_grid_3-fi.png

Vasen kuva on hetkestä juuri ennen kuin mato syö ruoan, joka on sen pään edessä. Oikealla kello on naksahtanut kerran ja ruoka syöty: muut segmentit ovat paikallaan, mutta niiden eteen on ilmestynyt uusi segmentti madon uudeksi etupääksi. Ruokaa on samalla ilmestynyt toisaalle.

  • Kasvata matoa etupäästä. Kun madon pää muuten etenisi ruoan kohdalle, älä liikuta mitään segmenttiä vaan lisää eteen ruoan tilalle yksi segmentti uudeksi pääksi. (Aiemmin etummaisena ollut segmentti jää toiseksi. Myös viimeinen segmentti säilyy paikoillaan. Ks. oheinen kuvapari.)

  • Ruoan on siirryttävä uuteen sijaintiin osana samaa advance-kutsua, joka tuo madon pään ruoan kohdalle. (advance-kutsun päättyessä ruoka ei koskaan ole madon pään kohdalla.)

  • Uuden vektorin muodostamisessa voit hyödyntää luvun 4.2 esittelemiä työkaluja, joita tuossa yllä pikkutehtävissä kerrattiin.

    • Segmentit ovat identtisiä. Jokaista segmenttiä ei tarvitse erikseen siirtää. Kaikki keskimmäiset segmentit säilyvät osana matoa; näennäinen liike syntyy, kunhan huolehdit madon etu- ja peräpäästä.

  • Alla on pieni lisävinkki, jotka voit paljastaa halutessasi.

    Vinkki madon segmenttien siirtämiseen

    Madon edetessä syömättä sinun on muodostettava uusi vektori, jossa on madon pään uuden sijainnin lisäksi kaikki madon aiemmat sijainnit paitsi viimeinen. Idea on ihan sama kuin yllä pikkutehtävässä, jossa liitettiin vektorin alkuun uusi luku.

    Muista, että pelkkä vektorin luominen ei pistä tuota uutta vektoria mihinkään talteen, vaan se pitää hoitaa sijoituskäskyllä.

  • Kokeile ohjelmaa tämän vaiheen lopuksi. Mato ei edelleenkään näytä kasvavan. Kasvaa se kyllä, mutta kasvu ei näy, koska käyttöliittymä ei piirrä näkyviin kuin madon pään.

Vaihe 4/5: grafiikka kuntoon

Siirry käyttöliittymään ja siellä makePic-metodiin. Huomaa:

  • Metodi lisää taustaa vasten vain yhden kappaleen SegmentPic-kuvaa (punertavaa madonosaa).

  • makePic käyttää samassa tiedostossa määriteltyä apufunktiota toPixelPos määrittääkseen ruudukkokoordinaattien perusteella pikselin, johon SegmentPic piirtyy.

  • makePicin käyttämä Pic-luokan metodi placeCopies ottaa ensimmäiseksi parametrikseen kuvan ja toiseksi vektorillisen sijainteja (Pos-olioita). Se toimii kuten tuttu place-metodi mutta sijoittaa taustaa vasten useita kopioita samasta kuvasta. Annettu koodi tosin antaa tuolle metodille parametriksi aina vain yksialkioisen vektorin.

Muokkaa makePic-metodia niin, että se piirtää kaikki madon segmentit identtisinä palluroina. Se käy näin:

  • Määritä kunkin segmentin kuvan sijainti toPixelPos-metodilla. Et tarvitse silmukkaa. Käytä apuna tämän luvun esittelemää kokoelmametodia.

    Vinkki

    Kokoelmassa on GridPos-sijainteja. Kokoelman, jossa on kutakin niistä vastaava Pos, saat helposti map-metodilla.

  • Anna placeCopies-metodille vektori, jossa ovat kaikki segmenttien sijainnit Pos-olioina.

Mato kasvaa!

Vaihe 5/5: törmäykset

Matopelien perinteeseen kuuluu, että mato voi törmätä paitsi seiniin myös itseensä. Huomioi tämä SnakeGame-luokan isOver-metodissa: pelin pitää päättyä myös, jos madon pää on päätynyt samaan ruutuun jonkin muun segmentin kanssa. (Siis vasta silloin, jos pään sijainti on jo sama kuin jonkin muun segmentin.)

Luvusta 4.2 löytyy taas työkaluja.

Vinkki

Madolla on pää ja häntä. Metodisi tulee tutkia, onko päässyt käymään niin, että pään sijainti on hännän sijaintien joukossa eli häntä sisältää pään. Kuten sanottu, työkalut juuri tuohon löytyvät luvusta 4.2.

Erikoistapaus

Mitä pitäisi tapahtua, kun täsmälleen kaksisegmenttinen mato kääntyy 180 astetta? Ehtiikö häntä pois pään alta vai ei? Vai pitäisikö suora käännös taaksepäin kokonaan estää? Saat itse päättää; tehtävän automaattitesti ei huomioi tätä tapausta.

A+ esittää tässä kohdassa tehtävän palautuslomakkeen.

Yhteenvetoa

  • Kokoelmille on Scala-kielen peruskirjastoissa määritelty koko joukko korkeamman asteen metodeita, joilla kokoelmien sisältöä voi käsitellä.

    • Yleisesti käytettyjä korkeamman asteen metodeita ovat mm. foreach, exists, forall, find, filter, map ja flatMap. Lisää esitellään myöhemmin.

    • Nämä metodit tarjoavat käteviä ratkaisuvaihtoehtoja moniin sellaisiin tilanteisiin, joissa silmukan käyttö olisi toinen vaihtoehto.

    • Tällainen kokoelmien käsittely on erityisen yleistä ns. funktionaalisessa ohjelmoinnissa, jota Scala voimakkaasti tukee.

  • Lukuun liittyviä termejä sanastosivulla: korkeamman asteen funktio; kokoelma; abstraktiotaso.

Tämän luvun merkityksestä

Useat tämän luvun esittelemistä metodeista ovat runsaassa käytössä tulevissa luvuissa. Niiden tunteminen helpottaa monien tulevien harjoitustehtävien tekemistä. Lisäksi sinun on kyettävä lukemaan annettua ohjelmakoodia, jossa näitä metodeita käytetään.

Kaikkien uusien metodien muistaminen ei varmasti heti onnistu, mutta ei tarvitsekaan. Voit palata kertaamaan esimerkiksi metodien nimiä ja muita yksityiskohtia tästä luvusta tai Scalaa kootusti -sivulta.

Tärkeintä on nyt muistaa perusajatus: kokoelmia voi käsitellä korkeamman asteen metodeilla, ja tarjolla on laaja valikoima erilaisia näppäriä metodeita.

Maistiainen: for–yield-lausekkeet

Mainituksi jo tulikin, että käyttämämme for–do-silmukat ovat vain toinen tapa kirjoittaa foreach-metodikutsu. Nämä siis tekevät saman:

lukuja.foreach( luku => println("Neliö on " + luku * luku) )

for luku <- lukuja do
  println("Neliö on " + luku * luku) )

Scalan for-rakenteella voi tehdä monenlaista muutakin (vaikkei O1:llä tarvitsekaan). Myös map-kutsun voi kirjoittaa for-sanaa käyttäen. Nämä tekevät saman:

val neliot = lukuja.map( luku => luku * luku )

val neliot = for luku <- lukuja yield luku * luku

yield on varattu sana, jolla for-lausekkeen saa tuottamaan muutakin kuin Unit.

Alla on puolestaan flatMap-kutsu sekä sen kanssa saman asian tekevä for–yield-lauseke. Kumpikin esimerkkikoodi käy lukuvektorin läpi kahdesti ja tuottaa kaikki mahdolliset kahden alkion summat.

val summat = for eka <- lukuja; toka <- lukuja yield eka + toka

val summat = lukuja.flatMap( eka => lukuja.map( toka => eka + toka ) )

for–yield-lausekkeen voi jaotella riveiksi esimerkiksi näin:

val summat =
  for
    eka <- lukuja
    toka <- lukuja
  yield eka + toka

Palaute

Huomaathan, että tämä on henkilökohtainen osio! Vaikka olisit tehnyt lukuun liittyvät tehtävät parin kanssa, täytä palautelomake itse.

Tekijät

Tämän oppimateriaalin kehitystyössä on käytetty apuna tuhansilta opiskelijoilta kerättyä palautetta. Kiitos!

Materiaalin luvut tehtävineen ja viikkokoosteineen on laatinut Juha Sorva.

Liitesivut (sanasto, Scala-kooste, usein kysytyt kysymykset jne.) on kirjoittanut Juha Sorva sikäli kuin sivulla ei ole toisin mainittu.

Tehtävien automaattisen arvioinnin ovat toteuttaneet: (aakkosjärjestyksessä) Riku Autio, Nikolas Drosdek, Kaisa Ek, Joonatan Honkamaa, Antti Immonen, Jaakko Kantojärvi, Onni Komulainen, Niklas Kröger, Kalle Laitinen, Teemu Lehtinen, Mikael Lenander, Ilona Ma, Jaakko Nakaza, Strasdosky Otewa, Timi Seppälä, Teemu Sirkiä, Joel Toppinen, Anna Valldeoriola Cardó ja Aleksi Vartiainen.

Lukujen alkuja koristavat kuvat ja muut vastaavat kuvituskuvat on piirtänyt Christina Lassheikki.

Yksityiskohtaiset animaatiot Scala-ohjelmien suorituksen vaiheista suunnittelivat Juha Sorva ja Teemu Sirkiä. Teemu Sirkiä ja Riku Autio toteuttivat ne apunaan Teemun aiemmin rakentamat työkalut Jsvee ja Kelmu.

Muut diagrammit ja materiaaliin upotetut vuorovaikutteiset esitykset laati Juha Sorva.

O1Library-ohjelmakirjaston ovat kehittäneet Aleksi Lukkarinen, Juha Sorva ja Jaakko Nakaza. Useat sen keskeisistä osista tukeutuvat Aleksin SMCL-kirjastoon.

Tapa, jolla käytämme O1Libraryn työkaluja (kuten Pic) yksinkertaiseen graafiseen ohjelmointiin, on saanut vaikutteita tekijöiden Flatt, Felleisen, Findler ja Krishnamurthi oppikirjasta How to Design Programs sekä Stephen Blochin oppikirjasta Picturing Programs.

Oppimisalusta A+ luotiin alun perin Aallon LeTech-tutkimusryhmässä pitkälti opiskelijavoimin. Nykyään tätä avoimen lähdekoodin projektia kehittää Tietotekniikan laitoksen opetusteknologiatiimi ja tarjoaa palveluna laitoksen IT-tuki; sitä ovat kehittäneet kymmenet Aallon opiskelijat ja muut.

A+ Courses -lisäosa, joka tukee A+:aa ja O1-kurssia IntelliJ-ohjelmointiympäristössä, on toinen avoin projekti. Sen suunnitteluun ja toteutukseen on osallistunut useita opiskelijoita yhteistyössä O1-kurssin opettajien kanssa.

Kurssin tämänhetkinen henkilökunta löytyy luvusta 1.1.

Joidenkin lukujen lopuissa on lukukohtaisia lisäyksiä tähän tekijäluetteloon.

a drop of ink
Palautusta lähetetään...