File content as of revision 22:16863912486d:

#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);
    cCollision col;
///////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////
    while(!perdu) {
        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);
        }
///////////////////////////////////////////////////////////////////////
        while(col.bordBas(*_ptrForme, *_mat) == false && col.pieceBas(*_ptrForme, *_mat) == false && !perdu) {
            mvt = _boussole->detectionMvt();

            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");
        }
        delete _ptrForme;
    }
    
    return 1;
}

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