mindbreaker.cpp

Trolltech公司发布的图形界面操作系统。可在qt-embedded-2.3.10平台上编译为嵌入式图形界面操作系统。

    /* min size is 200 x 260 */
/*
    if (s.width() < adjusted_board_width)
        s.setWidth(adjusted_board_width);

    if (s.height() < adjusted_board_height)
        s.setHeight(adjusted_board_height);
*/

    if ( current_highlight ) // non-first resize
	writeConfig();

    setupBoardSize(s.width() - fw, s.height() - fw);
    canvas()->resize(s.width() - fw, s.height() - fw);
    Peg::buildImages(); // must be done BEFORE any pegs are made

    QImage image = Resource::loadImage("mindbreaker/mindbreaker");

    /* copy from master image to functional images */
    int x = 0;
    int y = 0;
    panelImage = image.copy(x, y,  panel_width, panel_height).
		smoothScale( adjusted_panel_width, adjusted_panel_height);
    
    y += panel_height;
    y += panel_height;

    titleImage = image.copy(x, y, title_width, title_height).
		smoothScale( adjusted_title_width, adjusted_title_height);
    show();

    delete current_highlight;
    current_highlight = new Peg(canvas(), 8);
    current_highlight->setPlaced(TRUE);
    current_highlight->setX(0);
    current_highlight->setY(adjusted_board_height - ((current_go + 1) * adjusted_panel_height));
    current_highlight->setZ(0);
    current_highlight->show();

    /* set up the game */
    //readConfig();

    /* draw initial screen */
    //drawBackground();
    //canvas()->update();
    clear();

    readConfig();
}

void MindBreakerBoard::placeGuessPeg(int pos, int pegId)
{
        int x = adjusted_first_peg_x_diff + (pos * adjusted_peg_spacing);
        int y = adjusted_board_height - ((current_go + 1) * adjusted_panel_height) 
                + adjusted_first_peg_y_diff;

        Peg *peg = new Peg(canvas(), pegId, current_go, pos);
        peg->setPegPos(pos);
        peg->setPlaced(TRUE);
        peg->setX(x);
        peg->setY(y);
        peg->setZ(2);
        peg->show();
}

void MindBreakerBoard::drawBackground()
{
    int i, j, x, y, x_gap, y_gap;
    QPixmap background  = QPixmap(canvas()->width(), canvas()->height());

    QPainter painter(&background);

    painter.fillRect(0, 0, canvas()->width(), canvas()->height(), QColor(0,0,0));
    /* very first thing is to draw the bins, as everything else needs
     * to be drawn over them */

    QPen pen(QColor(85, 45, 27), 4);
    painter.setPen(pen);
    x_gap = canvas()->width() - (adjusted_panel_width + (2 * adjusted_bin_margin));
    //x_gap += peg_size >> 1;
    if (x_gap < 1) 
        x_gap = 1;

    y_gap = adjusted_board_height / 6;
    y_gap -= (2 * adjusted_bin_margin);
    //y_gap += peg_size >> 1;
    if (y_gap < 1) 
        y_gap = 1;
    x = adjusted_panel_width + adjusted_bin_margin - (adjusted_peg_size >> 1);
    y = adjusted_bin_margin - (adjusted_peg_size >> 1) + 2;

    for (i = 0; i < 6; i++) {
        for (j = 0; j < 10; j++) {
            int rx = x + (rand() % x_gap);
            int ry = y + (rand() % y_gap);
            painter.drawImage(rx,ry, Peg::imageForType(i));
        }
        y += adjusted_board_height / 6;
    }
    /* now draw the surrounding boxes */
    x_gap = canvas()->width() - adjusted_panel_width;
    if (x_gap < 1) x_gap = 1;
    y_gap = adjusted_board_height / 6;
    x = adjusted_panel_width;
    y = 1;

    for (i = 0; i < 6; i++) {
	painter.drawRect(x, y, x_gap, y_gap);
        y += y_gap;
    }

    x = 0;
    y = 0;

    painter.drawImage(x,y, titleImage);
    y = adjusted_title_height;
    /* now nine gues panels */
    for (i = 0; i < 9; i ++) {
        painter.drawImage(x, y, panelImage);
        y += adjusted_panel_height;
    }

    painter.flush();
    canvas()->setBackgroundPixmap(background);
}

void MindBreakerBoard::checkGuess()
{
    int i,j;
    int num_white = 0;
    int num_black = 0;
    int copy_answer[4];
    int copy_guess[4];

    for(i = 0; i < 4; i++) {
        copy_answer[i] = answer[i];
        copy_guess[i] = current_guess[i];
        if (current_guess[i] == 6)
            return;
        if (answer[i] == current_guess[i]) {
            num_black++;
            copy_answer[i] = 6;
            copy_guess[i] = 7; 
        }
    }

    /* now sure that user has completed a 'guess' */
    for (i = 0; i < 4; i++) {
        if (copy_guess[i] == 7)
            continue; // already marked for a black
        for (j = 0; j < 4; j++) {
            if(copy_guess[i] == copy_answer[j]) {
                copy_answer[j] = 6;
                num_white++;
                break;
            }
        }
    }

    int x = adjusted_answerpegx;
    int y = (adjusted_board_height - ((current_go + 1) * adjusted_panel_height)) + adjusted_answerpegy;
  
    if (num_black == 4)
        game_over = TRUE;

    while(num_black > 0) {
        Peg *p = new Peg(canvas(), 7);
        p->setPlaced(TRUE);
        p->setX(x);
        p->setY(y);
        p->setZ(1);
        p->show();
        num_black--;
        
        if (x == adjusted_answerpegx)
            x = adjusted_answerpegx + adjusted_answerpeg_xdiff;
        else  {
            x = adjusted_answerpegx;
            y += adjusted_answerpeg_ydiff;
        }
    }
    while(num_white > 0){
        Peg *p = new Peg(canvas(), 6);
        p->setPlaced(TRUE);
        p->setX(x);
        p->setY(y);
        p->setZ(1);
        p->show();
        num_white--;
        
        if (x == adjusted_answerpegx)
            x = adjusted_answerpegx + adjusted_answerpeg_xdiff;
        else  {
            x = adjusted_answerpegx;
            y += adjusted_answerpeg_ydiff;
        }
    }
    /* move to next go */
    for(i = 0; i < 4; i++) {
        past_guesses[4*current_go+i] = current_guess[i];
        current_guess[i] = 6;
    }

    current_go++;
    if((current_go > 8) || game_over) {
        total_games++;
        if(!game_over)
            total_turns += 10;
        else 
            total_turns += current_go;

        emit scoreChanged(total_turns, total_games);
        Peg *p = new Peg(canvas(), 9);
        game_over = TRUE;
        p->setPlaced(TRUE);
        p->setX(0);
        p->setY(0);
        p->setZ(0);
        p->show();
        
        for (i = 0; i < 4; i++) {
            p = new Peg(canvas(), answer[i], -1);
            p->setX(adjusted_first_peg_x_diff + (i * adjusted_peg_spacing));
            p->setY(adjusted_first_peg_y_diff);
            p->setZ(3);
            p->show();
        }
    } else {
       current_highlight->setY(adjusted_board_height - ((current_go + 1) * adjusted_panel_height));
    }
    canvas()->update();
}

void MindBreakerBoard::clear()
{
    if(!game_over) {
        total_games++;
        total_turns += 10;
        emit scoreChanged(total_turns, total_games);
    }
    int i;
    /* reset the game board */
    game_over = FALSE;
    /* clear the answer, clear the guess */
    for (i = 0; i < 4; i++) {
        answer[i] = rand() % 6;
        current_guess[i] = 6;
    }
    current_go = 0;

    QCanvasItemList list = canvas()->allItems();
    QCanvasItemList::Iterator it = list.begin();
    for (; it != list.end(); ++it) {
        if (*it == current_highlight)
            continue;
        if (*it)
            delete *it;
    }

    current_highlight->setY(adjusted_board_height - ((current_go + 1) * adjusted_panel_height));
    checkScores();
    drawBackground();
    canvas()->update();
}

void MindBreakerBoard::resetScore() 
{
    /* are u sure */

    if (QMessageBox::information(this, tr( "Reset Statistics" ), 
            tr( "<qt>Reset the win ratio?</qt>" ),
            tr( "OK" ), tr( "Cancel" ) ) == 0) {
        total_turns = 0;
        total_games = 0;
        Peg::eggLevel = 0;
        drawBackground();
        canvas()->update();
        emit scoreChanged(total_turns, total_games);
    }
}

/* EVENTS */

void MindBreakerBoard::contentsMousePressEvent(QMouseEvent *e)
{
    if (game_over) {
	null_press = TRUE;
	null_point = e->pos();
	moving = 0;
	return;
    }

    copy_press = FALSE;
    null_press = FALSE;
    /* ok, first work out if it is one of the bins that
       got clicked */
    if (e->x() > adjusted_panel_width) {
        /* its a bin, but which bin */
        int bin = (e->y() + 2) / (adjusted_board_height / 6);
	if (bin > 5)
            return; // missed everything

        /* make new peg... set it moving */
        moving_pos = e->pos();
        moving = new Peg(canvas(), bin, current_go);
        moving->setX(e->x() - (adjusted_peg_size >> 1));
        moving->setY(e->y() - (adjusted_peg_size >> 1));
        moving->setZ(5);
        moving->show();
        canvas()->update();
        return;
    }

    QCanvasItemList l = canvas()->collisions(e->pos());
    for (QCanvasItemList::Iterator it=l.begin(); it !=l.end(); ++it) {
        if ( (*it)->rtti() == pegRTTI ) {
            Peg *item = (Peg *)(*it);
            if (!item->hit(e->pos()))
                continue;
            if (item->type() > 5) {
                null_press = TRUE;
                null_point = e->pos();
                continue; /* not a color peg */
            }
            if (item->placed()) {
                /* copy */
                if(item->pegGo() == -1)
                    return;
                if(item->pegGo() == current_go) {
                    copy_press = TRUE;
                    copy_peg = item;
                }
                moving = new Peg(canvas(), 
                                 item->type(), current_go);
                moving->setX(e->x() - (adjusted_peg_size >> 1));
                moving->setY(e->y() - (adjusted_peg_size >> 1));
                moving->setZ(5);
                moving->show();
                moving_pos = QPoint(e->x(), e->y());
                canvas()->update();
                return;
            }
            moving = (Peg *)*it;
            moving_pos = e->pos();
            canvas()->update();
            return;
        }
    }
    null_press = TRUE;
    null_point = e->pos();
    moving = 0;
}

void MindBreakerBoard::contentsMouseMoveEvent(QMouseEvent* e)
{
    if (moving ) {
        moving->moveBy(e->pos().x() - moving_pos.x(),
                       e->pos().y() - moving_pos.y());
        moving_pos = e->pos();
        canvas()->update();
        return;
    } 
}

void MindBreakerBoard::contentsMouseReleaseEvent(QMouseEvent* e)
{
    /* time to put down the peg */
    if(moving) {
        if(copy_press) {
            /* check if collided with original. if so, delete both */
            copy_press = FALSE;
            QCanvasItemList l = canvas()->collisions(e->pos());
            for (QCanvasItemList::Iterator it=l.begin(); it !=l.end(); ++it) {
                if (*it == copy_peg) 
                    copy_press = TRUE;
            }
            if (copy_press) {
                current_guess[copy_peg->pegPos()] = 6;
                delete copy_peg;
                delete moving;
                copy_press = FALSE;
                moving = 0;
                copy_peg = 0;
                canvas()->update();
                return;
            }
        }
            
        /* first work out if in y */
        if (e->y() > (adjusted_board_height - (current_go * adjusted_panel_height))) {
            delete moving;
            moving = 0;
            canvas()->update();
            return;
        }
        if (e->y() < (adjusted_board_height - ((current_go + 1) * adjusted_panel_height))) {
            delete moving;
            moving = 0;
            canvas()->update();
            return;
        }
        /* ok, a valid go, but which peg */
        int x_bar = adjusted_first_peg_x_diff - (adjusted_peg_size >> 1);
        x_bar += adjusted_peg_spacing;
        int pos = 0;
        if (e->x() > x_bar) 
            pos = 1;
        x_bar += adjusted_peg_spacing;
        if (e->x() > x_bar)
            pos = 2;
        x_bar += adjusted_peg_spacing;
        if (e->x() > x_bar)
            pos = 3;
        x_bar += adjusted_peg_spacing;

        if (e->x() > x_bar) {
            /* invalid x */
            delete moving;
            moving = 0;
            canvas()->update();
            return;
        }

        int x = adjusted_first_peg_x_diff + (pos * adjusted_peg_spacing);
        int y = adjusted_board_height - ((current_go + 1) * adjusted_panel_height) 
                + adjusted_first_peg_y_diff;
        moving->setPegPos(pos);
        moving->setX(x);
        moving->setY(y);
        moving->setZ(2);

        /* remove all other pegs from this position */
        QCanvasItemList l = canvas()->collisions(QPoint(x,y));
        for (QCanvasItemList::Iterator it=l.begin(); it !=l.end(); ++it) {
            if ( (*it)->rtti() == pegRTTI ) {
                Peg *item = (Peg *)(*it);
                if ((item != moving) && (item != current_highlight))
                    delete item;
            }
        }
        current_guess[pos] = ((Peg *)moving)->type();

        ((Peg *)moving)->setPlaced(true);
        canvas()->update();
        return;
    }
    moving = 0;
    null_point -= e->pos();
    if(null_point.manhattanLength() < 6) {
        if (game_over) 
            clear();
        else 
            checkGuess();
    }
}

void MindBreakerBoard::resizeEvent(QResizeEvent *e)
{
    QCanvasView::resizeEvent(e);
    fixSize();
}


/* Easter egg function... beat the clock */
void MindBreakerBoard::checkScores()
{
    double games = total_games;
    double turns = total_turns;
    double g = games / 10.0;
    Peg::eggLevel = 0;

    double break_even = 5.0;
    if (g < 1.0) 
        return;
    double avg = turns / games;
    g--;
    while (break_even >= 0.0) {
        if (avg >= (break_even + g)) 
            return;
        // score a peg.
        break_even -= 1.0;
        Peg::eggLevel = int(5.0 - break_even);
    }
}