Oppaat: Peliohjelmointi, C++-matopeli: Osa 4 - Liike, törmäykset ja viimeistely

// peli.cpp; paikallisia vakioita
namespace peli {
	// Jaokkeen ja omenan säteet, puoli yksikköä kummatkin.
	static const float jaokkeen_sade = 0.5, omenan_sade = 0.5;

	// Madon kääntymisnopeus radiaaneina sekunnissa, puoli kierrosta.
	static const float pii = 3.14159265358979323846;
	static const float kaannosnopeus = pii;

	// Madon nopeus: 0,65 madonleveyttä 2,7 kertaa sekunnissa.
	// Nopeus ilmoitetaan kahtena lukuna, koska etenemä kertoo samalla
	// peräkkäisten jaokkeiden etäisyyden toisistaan.
	// (Mato on siistimpi, kun jaokkeet menevät hieman limittäin.)
	static const float vaihenopeus = 2.7;
	static const float etenema = 0.65 * 2 * jaokkeen_sade;

	// Mateluefektin heilahdus suhteessa madon etenemään matkaan.
	static const float matelun_heitto = 0.07;
}

// Tarvitaan matematiikkafunktiot esittelevä otsikkotiedosto peli.cpp:n alkuun.
#include <cmath>

// Liikuttaa matoa.
void peli::liikuta(mato& m, bool oikealle, bool vasemmalle) {
	// Käännetään matoa, jos toinen (ja vain toinen) napeista on pohjassa.
	if (oikealle && !vasemmalle) {
		m.suunta += ajan_muutos * kaannosnopeus;
	} else if (vasemmalle && !oikealle) {
		m.suunta -= ajan_muutos * kaannosnopeus;
	}
	// Muutetaan madon vaihetta ja käsitellään kokonaiset etenemiset.
	m.vaihe += ajan_muutos * vaihenopeus;
	while (m.vaihe >= 1) {
		m.vaihe -= 1;

		// Siirretään jokainen jaoke seuraavan kohdalle,
		// paitsi nenälle lasketaan uusi sijainti suunnan perusteella.
		for (mato::jaoke *j = m.hanta; j != m.nena; j = j->nenampi) {
			j->x0 = j->nenampi->x0;
			j->y0 = j->nenampi->y0;
		}
		m.nena->x0 += std::cos(m.suunta) * etenema;
		m.nena->y0 += std::sin(m.suunta) * etenema;
	}

	// Asetellaan jaokkeiden koordinaatit (x, y) sulavasti.
	// Tasaisessa liikkeessä riittäisi, että asetetaan jaokkeet vaiheen
	// mukaan oman perussijaintinsa ja seuraavan jaokkeen perussijainnin
	// välille. Nenän sijainti lasketaan madon suunnan perusteella.
	m.nena->x = m.nena->x0 + std::cos(m.suunta) * etenema * m.vaihe;
	m.nena->y = m.nena->y0 + std::sin(m.suunta) * etenema * m.vaihe;

	// Jotta mato aaltoilisi hieman, lisätään taaempien jaokkeiden
	// etenemiseen sinifunktion mukaan hieman sivusuuntaista heilahdusta.
	// Indeksin i avulla saadaan joka toinen jaoke liikkumaan eri puolelle.
	int i = 0;
	for (mato::jaoke *j = m.hanta; j != m.nena; j = j->nenampi) {
		++i;
		const float dx = j->nenampi->x0 - j->x0;
		const float dy = j->nenampi->y0 - j->y0;
		const float heitto = matelun_heitto * std::sin((2 * m.vaihe + i) * pii);
		j->x = j->x0 + m.vaihe * dx - heitto * dy;
		j->y = j->y0 + m.vaihe * dy + heitto * dx;
	}
}

namespace peli {
	// Apufunktio etäisyyden laskemiseen Pythagoraan lauseen avulla.
	static inline float etaisyys(float x0, float y0, float x1, float y1) {
		float dx = x1 - x0, dy = y1 - y0;
		return std::sqrt(dx * dx + dy * dy);
	}
}

// Tarkistaa osumisen omenaan.
bool peli::osuu_omenaan(mato const& m, omena const& o) {
	// Tarkistetaan nenän etäisyys omenasta.
	if (etaisyys(m.nena->x, m.nena->y, o.x, o.y) < jaokkeen_sade + omenan_sade) {
		return true;
	}
	return false;
}

// Arpoo omenan.
peli::omena peli::arvo_omena(const mato& m) {
	peli::omena o;
	// RAND_MAX on rand-funktion suurin mahdollinen arvo, joten sen avulla
	// voidaan skaalata arvonnan tulos välille [0, 1]. Tästä arvottu luku
	// on sitten helppo muuttaa muulle lukualueelle. Nyt sopiva lukualue
	// on sellainen, että omena jää ainakin hieman irti reunoista, jottei
	// sen syöminen olisi nurkastakaan liian vaikeaa.
	// Luku [0, 1] täytyy siis kertoa alueen koolla, ja siihen täytyy
	// lisätä alueen pienin koordinaatti.
	o.x = (float) std::rand() / RAND_MAX * (pelialue.x1 - pelialue.x0 - omenan_sade * 2) + pelialue.x0 + omenan_sade;
	o.y = (float) std::rand() / RAND_MAX * (pelialue.y1 - pelialue.y0 - omenan_sade * 2) + pelialue.y0 + omenan_sade;

	// Jos omena on liian lähellä madon päätä, siirretään se kauemmas.
	if (etaisyys(m.nena->x, m.nena->y, o.x, o.y) < 2 * (jaokkeen_sade + omenan_sade)) {
		// Valitaan kahdesta pelialueen kulmasta kauempi ja siirretään
		// omena puolet matkasta sinne päin.
		if (etaisyys(o.x, o.y, pelialue.x0, pelialue.y0) > etaisyys(o.x, o.y, pelialue.x1, pelialue.y1)) {
			o.x = (o.x + pelialue.x0) / 2;
			o.y = (o.y + pelialue.y0) / 2;
		} else {
			o.x = (o.x + pelialue.x1) / 2;
			o.y = (o.y + pelialue.y1) / 2;
		}
	}
	return o;
}

// Tarkistaa madon törmäyksen itseensä ja reunoihin.
bool peli::tormaa(mato const& m) {
	// Tarkistetaan nenän etäisyys kustakin reunasta.
	if (m.nena->x < pelialue.x0 + jaokkeen_sade) return true;
	if (m.nena->y < pelialue.y0 + jaokkeen_sade) return true;
	if (m.nena->x > pelialue.x1 - jaokkeen_sade) return true;
	if (m.nena->y > pelialue.y1 - jaokkeen_sade) return true;

	// Ei lasketa näennäistä "törmäystä" omiin jaokkeisiin, jotka ovat
	// lähellä heti nenän takana. Pidetään muuttujassa tieto, onko jo
	// löydetty jaoke, joka on tarpeeksi kaukana; törmäys lasketaan vain,
	// jos on jo löytynyt tarpeeksi kaukana oleva jaoke.
	bool lahella_nenaa = true;
	for (mato::jaoke *j = m.nena->hannampi; j != 0; j = j->hannampi) {
		// Jos jaoke on kaukana, muutetaan muuttujan arvoa, muuten
		// tarkistetaan muuttujasta, kuuluuko törmäys huomioida.
		if (etaisyys(j->x, j->y, m.nena->x, m.nena->y) > 2 * jaokkeen_sade) {
			// Ei törmätty tähän jaokkeeseen, joten tämä on tarpeeksi kaukana.
			lahella_nenaa = false;
		} else if (!lahella_nenaa) {
			// Törmätään oikeasti vain, jos on jo löytynyt kauempi jaoke.
			return true;
		}
	}
	return false;
}