e510b6e466
Fixed the include statements added QT+=widgets in examples/network to get them to compile. Will need something better than doing it manually.
409 lines
9.8 KiB
C++
409 lines
9.8 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
** All rights reserved.
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
**
|
|
** This file is part of the examples of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:BSD$
|
|
** You may use this file under the terms of the BSD license as follows:
|
|
**
|
|
** "Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions are
|
|
** met:
|
|
** * Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** * Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in
|
|
** the documentation and/or other materials provided with the
|
|
** distribution.
|
|
** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
|
|
** the names of its contributors may be used to endorse or promote
|
|
** products derived from this software without specific prior written
|
|
** permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include <QtWidgets>
|
|
|
|
#include "tetrixboard.h"
|
|
|
|
//! [0]
|
|
TetrixBoard::TetrixBoard(QWidget *parent)
|
|
: QFrame(parent)
|
|
{
|
|
setFrameStyle(QFrame::Panel | QFrame::Sunken);
|
|
setFocusPolicy(Qt::StrongFocus);
|
|
isStarted = false;
|
|
isPaused = false;
|
|
clearBoard();
|
|
|
|
nextPiece.setRandomShape();
|
|
}
|
|
//! [0]
|
|
|
|
//! [1]
|
|
void TetrixBoard::setNextPieceLabel(QLabel *label)
|
|
{
|
|
nextPieceLabel = label;
|
|
}
|
|
//! [1]
|
|
|
|
//! [2]
|
|
QSize TetrixBoard::sizeHint() const
|
|
{
|
|
return QSize(BoardWidth * 15 + frameWidth() * 2,
|
|
BoardHeight * 15 + frameWidth() * 2);
|
|
}
|
|
|
|
QSize TetrixBoard::minimumSizeHint() const
|
|
//! [2] //! [3]
|
|
{
|
|
return QSize(BoardWidth * 5 + frameWidth() * 2,
|
|
BoardHeight * 5 + frameWidth() * 2);
|
|
}
|
|
//! [3]
|
|
|
|
//! [4]
|
|
void TetrixBoard::start()
|
|
{
|
|
if (isPaused)
|
|
return;
|
|
|
|
isStarted = true;
|
|
isWaitingAfterLine = false;
|
|
numLinesRemoved = 0;
|
|
numPiecesDropped = 0;
|
|
score = 0;
|
|
level = 1;
|
|
clearBoard();
|
|
|
|
emit linesRemovedChanged(numLinesRemoved);
|
|
emit scoreChanged(score);
|
|
emit levelChanged(level);
|
|
|
|
newPiece();
|
|
timer.start(timeoutTime(), this);
|
|
}
|
|
//! [4]
|
|
|
|
//! [5]
|
|
void TetrixBoard::pause()
|
|
{
|
|
if (!isStarted)
|
|
return;
|
|
|
|
isPaused = !isPaused;
|
|
if (isPaused) {
|
|
timer.stop();
|
|
} else {
|
|
timer.start(timeoutTime(), this);
|
|
}
|
|
update();
|
|
//! [5] //! [6]
|
|
}
|
|
//! [6]
|
|
|
|
//! [7]
|
|
void TetrixBoard::paintEvent(QPaintEvent *event)
|
|
{
|
|
QFrame::paintEvent(event);
|
|
|
|
QPainter painter(this);
|
|
QRect rect = contentsRect();
|
|
//! [7]
|
|
|
|
if (isPaused) {
|
|
painter.drawText(rect, Qt::AlignCenter, tr("Pause"));
|
|
return;
|
|
}
|
|
|
|
//! [8]
|
|
int boardTop = rect.bottom() - BoardHeight*squareHeight();
|
|
|
|
for (int i = 0; i < BoardHeight; ++i) {
|
|
for (int j = 0; j < BoardWidth; ++j) {
|
|
TetrixShape shape = shapeAt(j, BoardHeight - i - 1);
|
|
if (shape != NoShape)
|
|
drawSquare(painter, rect.left() + j * squareWidth(),
|
|
boardTop + i * squareHeight(), shape);
|
|
}
|
|
//! [8] //! [9]
|
|
}
|
|
//! [9]
|
|
|
|
//! [10]
|
|
if (curPiece.shape() != NoShape) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
int x = curX + curPiece.x(i);
|
|
int y = curY - curPiece.y(i);
|
|
drawSquare(painter, rect.left() + x * squareWidth(),
|
|
boardTop + (BoardHeight - y - 1) * squareHeight(),
|
|
curPiece.shape());
|
|
}
|
|
//! [10] //! [11]
|
|
}
|
|
//! [11] //! [12]
|
|
}
|
|
//! [12]
|
|
|
|
//! [13]
|
|
void TetrixBoard::keyPressEvent(QKeyEvent *event)
|
|
{
|
|
if (!isStarted || isPaused || curPiece.shape() == NoShape) {
|
|
QFrame::keyPressEvent(event);
|
|
return;
|
|
}
|
|
//! [13]
|
|
|
|
//! [14]
|
|
switch (event->key()) {
|
|
case Qt::Key_Left:
|
|
tryMove(curPiece, curX - 1, curY);
|
|
break;
|
|
case Qt::Key_Right:
|
|
tryMove(curPiece, curX + 1, curY);
|
|
break;
|
|
case Qt::Key_Down:
|
|
tryMove(curPiece.rotatedRight(), curX, curY);
|
|
break;
|
|
case Qt::Key_Up:
|
|
tryMove(curPiece.rotatedLeft(), curX, curY);
|
|
break;
|
|
case Qt::Key_Space:
|
|
dropDown();
|
|
break;
|
|
case Qt::Key_D:
|
|
oneLineDown();
|
|
break;
|
|
default:
|
|
QFrame::keyPressEvent(event);
|
|
}
|
|
//! [14]
|
|
}
|
|
|
|
//! [15]
|
|
void TetrixBoard::timerEvent(QTimerEvent *event)
|
|
{
|
|
if (event->timerId() == timer.timerId()) {
|
|
if (isWaitingAfterLine) {
|
|
isWaitingAfterLine = false;
|
|
newPiece();
|
|
timer.start(timeoutTime(), this);
|
|
} else {
|
|
oneLineDown();
|
|
}
|
|
} else {
|
|
QFrame::timerEvent(event);
|
|
//! [15] //! [16]
|
|
}
|
|
//! [16] //! [17]
|
|
}
|
|
//! [17]
|
|
|
|
//! [18]
|
|
void TetrixBoard::clearBoard()
|
|
{
|
|
for (int i = 0; i < BoardHeight * BoardWidth; ++i)
|
|
board[i] = NoShape;
|
|
}
|
|
//! [18]
|
|
|
|
//! [19]
|
|
void TetrixBoard::dropDown()
|
|
{
|
|
int dropHeight = 0;
|
|
int newY = curY;
|
|
while (newY > 0) {
|
|
if (!tryMove(curPiece, curX, newY - 1))
|
|
break;
|
|
--newY;
|
|
++dropHeight;
|
|
}
|
|
pieceDropped(dropHeight);
|
|
//! [19] //! [20]
|
|
}
|
|
//! [20]
|
|
|
|
//! [21]
|
|
void TetrixBoard::oneLineDown()
|
|
{
|
|
if (!tryMove(curPiece, curX, curY - 1))
|
|
pieceDropped(0);
|
|
}
|
|
//! [21]
|
|
|
|
//! [22]
|
|
void TetrixBoard::pieceDropped(int dropHeight)
|
|
{
|
|
for (int i = 0; i < 4; ++i) {
|
|
int x = curX + curPiece.x(i);
|
|
int y = curY - curPiece.y(i);
|
|
shapeAt(x, y) = curPiece.shape();
|
|
}
|
|
|
|
++numPiecesDropped;
|
|
if (numPiecesDropped % 25 == 0) {
|
|
++level;
|
|
timer.start(timeoutTime(), this);
|
|
emit levelChanged(level);
|
|
}
|
|
|
|
score += dropHeight + 7;
|
|
emit scoreChanged(score);
|
|
removeFullLines();
|
|
|
|
if (!isWaitingAfterLine)
|
|
newPiece();
|
|
//! [22] //! [23]
|
|
}
|
|
//! [23]
|
|
|
|
//! [24]
|
|
void TetrixBoard::removeFullLines()
|
|
{
|
|
int numFullLines = 0;
|
|
|
|
for (int i = BoardHeight - 1; i >= 0; --i) {
|
|
bool lineIsFull = true;
|
|
|
|
for (int j = 0; j < BoardWidth; ++j) {
|
|
if (shapeAt(j, i) == NoShape) {
|
|
lineIsFull = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (lineIsFull) {
|
|
//! [24] //! [25]
|
|
++numFullLines;
|
|
for (int k = i; k < BoardHeight - 1; ++k) {
|
|
for (int j = 0; j < BoardWidth; ++j)
|
|
shapeAt(j, k) = shapeAt(j, k + 1);
|
|
}
|
|
//! [25] //! [26]
|
|
for (int j = 0; j < BoardWidth; ++j)
|
|
shapeAt(j, BoardHeight - 1) = NoShape;
|
|
}
|
|
//! [26] //! [27]
|
|
}
|
|
//! [27]
|
|
|
|
//! [28]
|
|
if (numFullLines > 0) {
|
|
numLinesRemoved += numFullLines;
|
|
score += 10 * numFullLines;
|
|
emit linesRemovedChanged(numLinesRemoved);
|
|
emit scoreChanged(score);
|
|
|
|
timer.start(500, this);
|
|
isWaitingAfterLine = true;
|
|
curPiece.setShape(NoShape);
|
|
update();
|
|
}
|
|
//! [28] //! [29]
|
|
}
|
|
//! [29]
|
|
|
|
//! [30]
|
|
void TetrixBoard::newPiece()
|
|
{
|
|
curPiece = nextPiece;
|
|
nextPiece.setRandomShape();
|
|
showNextPiece();
|
|
curX = BoardWidth / 2 + 1;
|
|
curY = BoardHeight - 1 + curPiece.minY();
|
|
|
|
if (!tryMove(curPiece, curX, curY)) {
|
|
curPiece.setShape(NoShape);
|
|
timer.stop();
|
|
isStarted = false;
|
|
}
|
|
//! [30] //! [31]
|
|
}
|
|
//! [31]
|
|
|
|
//! [32]
|
|
void TetrixBoard::showNextPiece()
|
|
{
|
|
if (!nextPieceLabel)
|
|
return;
|
|
|
|
int dx = nextPiece.maxX() - nextPiece.minX() + 1;
|
|
int dy = nextPiece.maxY() - nextPiece.minY() + 1;
|
|
|
|
QPixmap pixmap(dx * squareWidth(), dy * squareHeight());
|
|
QPainter painter(&pixmap);
|
|
painter.fillRect(pixmap.rect(), nextPieceLabel->palette().background());
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
int x = nextPiece.x(i) - nextPiece.minX();
|
|
int y = nextPiece.y(i) - nextPiece.minY();
|
|
drawSquare(painter, x * squareWidth(), y * squareHeight(),
|
|
nextPiece.shape());
|
|
}
|
|
nextPieceLabel->setPixmap(pixmap);
|
|
//! [32] //! [33]
|
|
}
|
|
//! [33]
|
|
|
|
//! [34]
|
|
bool TetrixBoard::tryMove(const TetrixPiece &newPiece, int newX, int newY)
|
|
{
|
|
for (int i = 0; i < 4; ++i) {
|
|
int x = newX + newPiece.x(i);
|
|
int y = newY - newPiece.y(i);
|
|
if (x < 0 || x >= BoardWidth || y < 0 || y >= BoardHeight)
|
|
return false;
|
|
if (shapeAt(x, y) != NoShape)
|
|
return false;
|
|
}
|
|
//! [34]
|
|
|
|
//! [35]
|
|
curPiece = newPiece;
|
|
curX = newX;
|
|
curY = newY;
|
|
update();
|
|
return true;
|
|
}
|
|
//! [35]
|
|
|
|
//! [36]
|
|
void TetrixBoard::drawSquare(QPainter &painter, int x, int y, TetrixShape shape)
|
|
{
|
|
static const QRgb colorTable[8] = {
|
|
0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
|
|
0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00
|
|
};
|
|
|
|
QColor color = colorTable[int(shape)];
|
|
painter.fillRect(x + 1, y + 1, squareWidth() - 2, squareHeight() - 2,
|
|
color);
|
|
|
|
painter.setPen(color.light());
|
|
painter.drawLine(x, y + squareHeight() - 1, x, y);
|
|
painter.drawLine(x, y, x + squareWidth() - 1, y);
|
|
|
|
painter.setPen(color.dark());
|
|
painter.drawLine(x + 1, y + squareHeight() - 1,
|
|
x + squareWidth() - 1, y + squareHeight() - 1);
|
|
painter.drawLine(x + squareWidth() - 1, y + squareHeight() - 1,
|
|
x + squareWidth() - 1, y + 1);
|
|
}
|
|
//! [36]
|