// peli.cpp; paikallisia vakioita
namespace {
    // 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;
}