clases.cpp

#include "clases.h"

//===============================================
//== CONSTRUCTOR
//===============================================
Panel_sort::Panel_sort(QGraphicsRectItem *rectangulo)
{
    //== Tenemos una funcion que reestablece la semilla del random, diremos que se ejecute cada 12 segundos
    refresh_seed();
    QTimer *timer = new QTimer();
    connect(timer,SIGNAL(timeout()),this,SLOT(refresh_seed()));
    timer->start(12*1000);

    //== Ponemos los numeros sorteados en false
    reset();

    //== Calculamos las dimensiones de las casillas segun el rectangulo establecido
    int x = rectangulo->rect().x(),
        y = rectangulo->rect().y(),
        depX = (int) (rectangulo->rect().width() / 10),
        depY = (int) (rectangulo->rect().height() / 6);

    //== Contador de numeros, empezamos desde el 1 para luego acceder de forma mas directa al array
    int count = 1;

    //== Creamos un ciclo que crea todas las casillas del panel con sus numeros correspondientes
    for(char u=0; u<6; u++)
    {
        for(char i=0; i<10; i++)
        {
            int x1 = x + (depX * i),
                y1 = y + (depY * u);

            text[count].setPlainText(QString::number(count));
            text[count].setPos(x1,y1);
            rectangulo->scene()->addItem(&text[count]);
            count++;
        }
    }
}

void Panel_sort::reset()
{
    for(int i=0; i<ArraySize(numeros); i++)
    {
        text[i].setFont(QFont("arial",15));
        text[i].setDefaultTextColor(Qt::gray);
        numeros[i]=false;
    }
}

void Panel_sort::nuevo_numero()
{
    //== Proceso para solo dar por validos numeros nuevos
    bool buen_rand=false;
    int num;
    while(!buen_rand)
    {
        num = 1 + (rand() % 60);
        buen_rand=true;
        for(int i=0; i<ArraySize(numeros) && buen_rand; i++)
        {
            if(numeros[num] == true){ buen_rand=false; }
        }
    }
    numeros[num]=true;
    text[num].setFont(QFont("arial",17));
    text[num].setDefaultTextColor(Qt::green);
}

void Panel_sort::refresh_seed()
{
    QTime time;
    time.start();
    srand(time.msecsSinceStartOfDay());
}

//===============================================
//== CONSTRUCTOR DE LA CLASE CARTON (PAPELETA con los numeros)
//===============================================
Carton::Carton(QGraphicsRectItem *rectangulo)
{
    //== Nos guardamos el puntero de la escena que nos servirá mas tarde
    m_scene = rectangulo->scene();

    //== Calculamos las dimensiones de los numeros segun el rectangulo establecido
    int x = rectangulo->rect().x(),
        y = rectangulo->rect().y(),
        depX = (int) (rectangulo->rect().width() / 5),
        depY = (int) (rectangulo->rect().height() / 3);

    //== Asignamos la posicion a los numeros
    int count = 0;
    for(char u=0; u<3; u++)
    {
        for(char i=0; i<5; i++)
        {
            int x1 = x + (depX * i),
                y1 = y + (depY * u);

            numeros[count].setPos(x1 + 15,y1 + 15);
            m_scene->addItem(&numeros[count]);
            count++;

            //== Dibujamos un cuadradito contenedor de los numeros
            int m=2;
            QGraphicsRectItem *r = new QGraphicsRectItem(x1+m,y1+m,depX-m,depY-m);
            m_scene->addItem(r);
        }
    }

    Nuevo_Carton();
}

//== Asigna los numeros de un nuevo carton
void Carton::Nuevo_Carton()
{
    //== Ponemos a -1 el array de numeros tipo int
    for(int i=0; i<ArraySize(int_numeros); i++)
    {
        numeros[i].setFont(QFont("arial",35));
        numeros[i].setDefaultTextColor(Qt::black);
        int_numeros[i]=-1;
    }

    //== Ciclo para generar los numeros de la papeleta
    for(int i=0; i<ArraySize(numeros); i++)
    {
        //== Proceso para solo dar por validos numeros nuevos
        bool buen_rand=false;
        while(!buen_rand)
        {
            buen_rand=true;

            int_numeros[i] = 1 + (rand() % 60);
            for(int u=i-1; u>=0; u--)
            {
                if(int_numeros[i] == int_numeros[u]){ buen_rand=false; }
            }
        }
        numeros[i].setPlainText(QString::number(int_numeros[i]));
    }
}

//== CONSTRUCTOR DE LA CLASE GAME
Game::Game(Panel_sort *num_sort, Carton *carton)
{
    m_sorteo = num_sort;
    m_carton = carton;
    score=0;

    score_text.setPos(350,170);
    score_text.setFont(QFont("arial",20));
    score_text.setPlainText(QString("PREMIO ACUMULADO = ")+QString::number(score));
    m_carton->m_scene->addItem(&score_text);

    num_lanz.setPos(350,20);
    num_lanz.setFont(QFont("arial",15));
    m_carton->m_scene->addItem(&num_lanz);

    partida();
}

void Game::partida()
{
    if(message_step>0){ return; }

    m_carton->Nuevo_Carton();
    m_sorteo->reset();
    numeros_lanzados=0;
    num_lanz.setPlainText(QString("<- NUM SORTEADOS = ")+QString::number(numeros_lanzados));
    lineas[0]=false; lineas[1]=false; lineas[2]=false;
    bingo=false; mensaje("CARTON NUEVO");

    t.start(500);
    connect(&t,SIGNAL(timeout()),this,SLOT(lanzada()));
}

void Game::lanzada()
{
    //== Incrementamos el contador de numeros lanzados y salimos si ha acabado esta partida
    numeros_lanzados++;
    if(numeros_lanzados<=30)
    {
        num_lanz.setPlainText(QString("<- NUM SORTEADOS = ")+QString::number(numeros_lanzados));
    }

    if(numeros_lanzados > 30 || bingo)
    {
        disconnect(&t,SIGNAL(timeout()),this,SLOT(lanzada()));
        partida();
        return;
    }

    //== Lanzamos nuevo numero
    m_sorteo->nuevo_numero();

    //== Chequeo si el numero ha coincidido y lo marco
    for(int i=0; i<ArraySize(m_carton->int_numeros); i++)
    {
        int n = m_carton->int_numeros[i];
        if(n>0)
        {
            if(m_sorteo->numeros[n])
            {
                m_carton->int_numeros[i] = -1;
                m_carton->numeros[i].setDefaultTextColor(Qt::red);
            }
        }
    }

    //== Comprobamos si hay BINGO
    bingo=true;
    for(int i=0; i<ArraySize(m_carton->int_numeros) && bingo; i++)
    {
        if(m_carton->int_numeros[i]>0){ bingo = false; }
    }
    if(bingo)
    {
        score+=1500;
        score_text.setPlainText(QString("PREMIO ACUMULADO = ")+QString::number(score));
        mensaje("BINGOOOOOO!!!");
        return;
    }

    //== Comprobamos si hay alguna linea
    for(int i=0; i<3; i++)
    {
        if(!lineas[i])
        {
            int start = i * 5,
                end = start + 5;

            lineas[i]=true;
            for(int u=start; u<end && lineas[i]; u++)
            {
                if(m_carton->int_numeros[u]>0){ lineas[i]=false; }
            }

            if(lineas[i])
            {
                score+=10;
                score_text.setPlainText(QString("PREMIO ACUMULADO = ")+QString::number(score));
                mensaje("LINEA "+QString::number(i + 1)+"!!!!!");
            }
        }
    }
}

void Game::mensaje(QString text)
{
    //== Si habia un mensaje en pantalla eliminalo primero
    if(message_step!=0)
    {
        disconnect(&mt,SIGNAL(timeout()),this,SLOT(mensaje_slot()));
        m_carton->m_scene->removeItem(&message);
        message_step=0;
    }

    message.setPos(50,500);
    message.setFont(QFont("arial",10));
    message.setDefaultTextColor(Qt::yellow);
    message.setPlainText(text);
    message.setOpacity(1);

    m_carton->m_scene->addItem(&message);

    connect(&mt,SIGNAL(timeout()),this,SLOT(mensaje_slot()));
    mt.start(50);

}

void Game::mensaje_slot()
{
    message_step++;
    if(message_step>100)
    {
        disconnect(&mt,SIGNAL(timeout()),this,SLOT(mensaje_slot()));
        m_carton->m_scene->removeItem(&message);
        message_step=0;
        if(numeros_lanzados >= 30){ partida(); }

    }
    else if(message_step<60)
    {
        message.setPos(message.x(),message.y() - 7);
        message.setFont(QFont("arial",10 + message_step));
    }
    else
    {
        message.setOpacity(message.opacity() - 0.05);
    }
}