File content as of revision 21:f0cf4173ecdb:

#include "cJeu.h"

cJeu::cJeu()
{

}

cJeu::cJeu(unsigned char x, unsigned char y)
{
    //: _interrupt(pb)         // create the InterruptIn on the pin specified to Counter
        ///////////////////////////////////////////////////
//_interrupt.rise(this, &cBoussole::detectionMvt);
    //on crée une nouvelle matrice
    _mat = new cMatrice(x, y);
    //on initialise la générateur de nombres pseudo-aléatoires
    srand(time(NULL));
    ///////////////////////////////////////////
    _boussole = new cBoussole(p9,p10);


}

cMatrice* cJeu::get_matrice()
{
    return _mat;
}

unsigned char cJeu::get_score()
{
    return _score;
}

void cJeu::set_matrice(cMatrice *mat)
{
    _mat = mat;
}

void cJeu::set_score(unsigned char sc)
{
    _score = sc;
}

void cJeu::initialiser()
{
    _spi.initSPI(100000, 8, 3);
    _mat->clear();
    _spi.envoyerMatrice(*_mat);
}

//  Description:
// Créé une nouvelle pièce et renvoi l'adresse de cette dernière
void cJeu::nouvellePiece()
{
    //on génère un nombre aléatoire entre 1 et 5 pour la pièce
    unsigned char nb = 1 + ((float)rand()/RAND_MAX) * 5;
    //on génère un deuxième nombre pour choisir la couleur de la pièce
    unsigned char couleur = 1 + ((float)rand()/RAND_MAX) * 7;
    //selon le nombre généré, on va créer une nouvelle pièce
    switch(nb) {
            //on crée une pièce "L"
        case 1: {
            _ptrForme = new cEl(3,0);
            break;
        }
        //on crée une pièce "ligne"
        case 2: {
            _ptrForme = new cLigne(3,0);
            break;
        }
        //on crée une pièce "Z"
        case 3: {
            _ptrForme = new cZed(3,0);
            break;
        }
        //on crée une pièce "T"
        case 4: {
            _ptrForme = new cTe(3,0);
            break;
        }
        //on crée une pièce "carré"
        case 5: {
            _ptrForme = new  cCarre(3,0);
            break;
        }
        default:
        {}

    }//et on choisi sa couleur
    switch(couleur) {
        case 1: {
            couleur = LED_ROUGE;
            break;
        }
        case 2: {
            couleur = LED_ORANGE;
            break;
        }
        case 3: {
            couleur = LED_JAUNE;
            break;
        }
        case 4: {
            couleur = LED_VERT;
            break;
        }
        case 5: {
            couleur = LED_BLEU_CLAIR;
            break;
        }
        case 6: {
            couleur = LED_BLEU_FONCE;
            break;
        }
        case 7: {
            couleur = LED_MAGENTA;
            break;
        }
        default:
        {}
    }

    //puis on affiche la nouvelle pièce
    _mat->afficherForme(_ptrForme, couleur);
    _spi.envoyerMatrice(*_mat);
}

cJeu::~cJeu()
{
    delete _ptrForme;
}

void cJeu::nouvelleManche()
{
    //cJeu::nouvelleLigne();
    //tant que l'on peut descendre
    //while(frfd)


    //puis on teste si une ligne est complete
    cJeu::ligneComplete();

}
unsigned char cJeu::ligneComplete()
{
    Serial pc(USBTX, USBRX);

    unsigned char total = 0, numLigne = 0;
    /*on parcourt chaque ligne de la matrice.
    Si une de ces lignes est complète (c-à-d pas de LED noire), alors
    on fait descendre toutes les pièces au-dessus de la ligne(autres que celle de la manche) d'un cran.
    */
    for( unsigned char i = 0; i < _mat->getLig(); i++) {
        total = 0;
        for( unsigned char j = 0; j < _mat->getCol(); j++) {
            if(_mat->getValTab(j, i) != LED_NOIR) {
                total ++;
            }
            if(total == 8) {
                numLigne = i;
                break;
            } else {
                return 0;   // PAS DE LIGNE COMPLETE
            }
        }
    }
    pc.printf("numLigne: %d\n", numLigne);
    //////////////////////////////////////////////
    //On descend toutes les LEDs allumées au dessus de numLigne d'un cran
    if(numLigne != 0) {
        for( unsigned char i = 0; i < numLigne; i++) {
            total = 0;
            for( unsigned char j = 0; j < _mat->getCol(); j++) {
                _mat->setValTab(j, i, _mat->getValTab(j-1, i));
            }
        }
        //Et on augmente le score!
        _score+=10;
    }
    return 1;
}

int cJeu::partieEnCours()
{
    /////
    int perdu;
    unsigned char mvt;
    perdu = 0;
///////////////////////////////////////////////////////////////////////
    Serial pc(USBTX, USBRX); // tx, rx
    DigitalOut led(LED1);
    /*
    _mat->setValTab(7, 0, LED_VERT);
    _mat->setValTab(5, 5, LED_VERT);
    _mat->setValTab(6, 2, LED_VERT);*/
    cCollision col;

    ////////////////////////////////////////
    //  DEMANDE UTILISATEUR


    ////////////////////////////////////////
    //  CONTROLE COLLISION

    /*    _ptrForme = new cZed(3,0);
        _mat->afficherForme(_ptrForme, LED_ROUGE);
        _spi.envoyerMatrice(*_mat);*/
    ////////////////////////////////////////
    //  MOUVEMENT
    nouvellePiece();
    if(col.pieceBas(*_ptrForme, *_mat) == true) {
        perdu = 1;
        wait(0.5);
        for(unsigned char i = 0; i < _mat->getLig(); i++) {
            for(unsigned char j = 0; j < _mat->getCol(); j++) {
                _mat->setValTab(i, j, LED_BLEU_FONCE);
            }
        }
        _spi.envoyerMatrice(*_mat);
        wait(0.5);
        _mat->clear();
        _spi.envoyerMatrice(*_mat);
    }
    /*     _ptrForme->deplacementBas();
      _mat->updateMatrice();
     _spi.envoyerMatrice(*_mat);
             wait(0.5);*/
    while(!perdu) {


        //si la nouvelle pièce ne peut pas descendre, alors on a perdu.
        //on change la couleur de la matrice puis
        //On efface la matrice
        /*if(col.pieceBas(*_ptrForme, *_mat) == true) {
            perdu = 1;
            wait(0.5);
            for(unsigned char i = 0; i < _mat->getLig(); i++) {
                for(unsigned char j = 0; j < _mat->getCol(); j++) {
                    _mat->setValTab(i, j, LED_BLEU_FONCE);
                }
            }
            _spi.envoyerMatrice(*_mat);
            wait(0.5);
            _mat->clear();
            _spi.envoyerMatrice(*_mat);

        } else {
            */
        //while(col.pieceBas(*_ptrForme, *_mat) == false && col.bordBas(*_ptrForme, *_mat) == false) {
        //on récupère l'information de mouvement
        /*if(col.pieceBas(*_ptrForme, *_mat) == true || col.bordBas(*_ptrForme, *_mat) == true) {
            perdu = 1;
        }*/
        
        //led = 1;
        //while(!mvt) {
            mvt = _boussole->detectionMvt();
        //}
        //led = 0;
        switch(mvt) {
            case 'a': {
                if(col.pieceBas(*_ptrForme, *_mat) == false && col.bordBas(*_ptrForme, *_mat) == false) {
                    _ptrForme->deplacementBas();
                }
                break;
            }
            case 'g': {

                if(col.pieceGauche(*_ptrForme, *_mat) == false && col.bordGauche(*_ptrForme) == false) {
                    _ptrForme->deplacementGauche();
                }
                break;
            }
            case 'd': {

                if(col.pieceDroite(*_ptrForme, *_mat) == false && col.bordDroit(*_ptrForme) == false) {
                    _ptrForme->deplacementDroite();
                }
                break;
            }
            case  'l': {
                if(col.pieceBas(*_ptrForme, *_mat) == false && col.bordBas(*_ptrForme, *_mat) == false) {
                    _ptrForme->rotationHoraire();
                }
                break;
            }
            case  'r': {
                if(col.pieceBas(*_ptrForme, *_mat) == false && col.bordBas(*_ptrForme, *_mat) == false) {
                    _ptrForme->rotationHoraire();
                    _ptrForme->rotationHoraire();
                    _ptrForme->rotationHoraire();
                }
                break;
            }
            default:
            {}
        }
        //on rafraîchi la matrice
        _mat->updateMatrice();
        _spi.envoyerMatrice(*_mat);
        wait(0.2);
        //et si on peut on descend la pièce
        if(col.pieceBas(*_ptrForme, *_mat) == false && col.bordBas(*_ptrForme, *_mat) == false) {
            _ptrForme->deplacementBas();
            _mat->updateMatrice();
            _spi.envoyerMatrice(*_mat);
        }
        wait(0.2);
        //} le else
        // pc.printf(" Collision !!!!\n");
        //pc.printf("prochaine manche\n");

    }
    return 0;
}

void cJeu::fin()
{
    delete _ptrForme;
    delete _boussole;
    delete _mat;
}