void localMap::paintTile(QPainter &painter,
int row, int col,
char type)
{
painter.setPen(Qt::NoPen);
if(type == 'g')
painter.setBrush(Qt::green);
else if(type == 'r')
painter.setBrush(Qt::gray);
else if(type == 'n')
painter.setBrush(Qt::black);
else if(type == 'd')
painter.setBrush(QColor(250, 25, 150));
else if(type == 'u')
painter.setBrush(QColor(250, 150, 25));
else if(type == 'p')
painter.setBrush(Qt::red);
else if(type == 'i')
painter.setBrush(QColor(0, 125, 0));
else if(type == 'w')
painter.setBrush(Qt::blue);
painter.drawRect(currentTile(row, col));
}
void GraphicalBoardFrame::resizeWidgets(int sideLength)
{
PixmapCacher::self()->invalidate();
bool firstTile = true;
for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
{
for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
{
TileWidget *tile = tileAt(currentTile);
if (!tile)
continue;
tile->setSideLength(sideLength);
if (firstTile)
{
emit tileFontChanged(tile->actualLetterFont());
firstTile = false;
}
}
}
for (int row = 0; row <= m_boardSize.height(); ++row)
{
TileWidget *mark = markAt(QSize(0, row));
mark->setSideLength(sideLength);
}
for (int col = 1; col <= m_boardSize.width(); ++col)
{
TileWidget *mark = markAt(QSize(col, 0));
mark->setSideLength(sideLength);
}
}
void GraphicalBoardFrame::deleteWidgets()
{
if (m_boardSize.isEmpty())
return;
for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
{
for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
{
delete tileAt(currentTile);
removeTile(currentTile);
}
}
for (int row = 0; row <= m_boardSize.height(); ++row)
{
delete markAt(QSize(0, row));
removeMark(QSize(0, row));
}
for (int col = 1; col <= m_boardSize.width(); ++col)
{
delete markAt(QSize(col, 0));
removeMark(QSize(col, 0));
}
}
void GraphicalBoardFrame::generateBoardPixmap(QPixmap *pixmap)
{
if (m_sizeForBoard.isEmpty())
{
*pixmap = QPixmap(0, 0);
return;
}
*pixmap = QPixmap(m_sizeForBoard);
QPainter painter(pixmap);
for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
{
for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
{
TileWidget *tile = tileAt(currentTile);
if (!tile)
continue;
painter.drawPixmap(coordinatesOfTile(currentTile), tile->tilePixmap());
}
}
for (int row = 0; row <= m_boardSize.height(); ++row)
{
const QSize location(0, row);
painter.drawPixmap(coordinatesOfMark(location), markAt(location)->tilePixmap());
}
for (int col = 1; col <= m_boardSize.width(); ++col)
{
const QSize location(col, 0);
painter.drawPixmap(coordinatesOfMark(location), markAt(location)->tilePixmap());
}
}
void TileMapEditor::updateFromTilePicker() {
switch (toolManager_.currentTool()) {
case TileMapEditorTools::pencil:
break;
default:
currentTile().setTileNum(
tilePickerPreview_.pickedIndex() - currentTileMapInfo().offset);
break;
}
}
void TileMapEditor::updateFromTileMap() {
switch (toolManager_.currentTool()) {
case TileMapEditorTools::pencil:
tilePickerPreview_.pickIndex(
toolManager_.pencilDrawIndex() + currentTileMapInfo().offset);
break;
default:
tilePickerPreview_.pickIndex(currentTile().tileNum()
+ currentTileMapInfo().offset);
break;
}
}
void GraphicalBoardFrame::drawMove(const Quackle::Move &move)
{
if (move.action == Quackle::Move::Place)
{
if (move.tiles().empty())
return;
const QSize startTile(move.startcol, move.startrow);
const Quackle::LetterString::const_iterator end(move.tiles().end());
int i = 0;
for (Quackle::LetterString::const_iterator it = move.tiles().begin(); it != end; ++it, ++i)
{
// if this is a cemented letter that we shouldn't overwrite
if (move.isAlreadyOnBoard(*it))
continue;
QSize currentTile(startTile);
if (move.horizontal)
currentTile.setWidth(currentTile.width() + i);
else
currentTile.setHeight(currentTile.height() + i);
TileWidget *tileWidget = tileAt(currentTile);
if (!tileWidget)
continue;
Quackle::Board::TileInformation info;
info.tileType = Quackle::Board::LetterTile;
info.isBlank = QUACKLE_ALPHABET_PARAMETERS->isBlankLetter(*it);
info.letter = QUACKLE_ALPHABET_PARAMETERS->clearBlankness(*it);
tileWidget->setInformation(info);
tileWidget->setCemented(false);
tileWidget->prepare();
}
}
}
void GraphicalBoardFrame::recreateWidgets()
{
Quackle::Board emptyBoard;
emptyBoard.prepareEmptyBoard();
for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
{
for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
{
TileWidget *newTile = new TileWidget;
newTile->setLocation(currentTile);
newTile->setAlwaysShowVerboseLabels(m_alwaysShowVerboseLabels);
newTile->setOriginalInformation(emptyBoard.tileInformation(currentTile.height(), currentTile.width()));
addTile(currentTile, newTile);
}
}
for (int row = 0; row <= m_boardSize.height(); ++row)
{
MarkWidget *newMark = new MarkWidget;
if (row == 0)
newMark->setCapstone();
else
newMark->setRow(row);
addMark(QSize(0, row), newMark);
}
for (int col = 1; col <= m_boardSize.width(); ++col)
{
MarkWidget *newMark = new MarkWidget;
newMark->setCol(col);
addMark(QSize(col, 0), newMark);
}
}
void GraphicalBoardFrame::drawBoard(const Quackle::Board &board)
{
QSize newBoardSize(board.width(), board.height());
if (m_boardSize != newBoardSize)
{
// if it was empty, we need to recalculate
// tile widths
bool wasEmpty = m_boardSize.isEmpty();
deleteWidgets();
m_boardSize = newBoardSize;
recreateWidgets();
if (wasEmpty)
expandToSize(m_maxSize);
}
for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
{
for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
{
Quackle::Board::TileInformation info(board.tileInformation(currentTile.height(), currentTile.width()));
TileWidget *tile = tileAt(currentTile);
if (!tile)
continue;
tile->setInformation(info);
tile->setArrowDirection(NoArrow);
tile->setCemented(info.tileType == Quackle::Board::LetterTile);
tile->prepare();
}
}
}
void GraphicalBoardFrame::tileClicked(const QSize &tileLocation, const QMouseEvent * /* event */)
{
Quackle::Board::TileInformation info(m_board.tileInformation(tileLocation.height(), tileLocation.width()));
if (info.tileType == Quackle::Board::LetterTile)
return;
if (m_arrowRoot == tileLocation)
{
++m_arrowDirection;
if (m_arrowDirection == ArrowWorm)
m_arrowDirection = s_firstArrowDirection;
}
else
m_arrowDirection = s_firstArrowDirection;
m_arrowRoot = tileLocation;
Quackle::Move originalMove;
Quackle::LetterString hoppedTiles;
QSize currentTile(tileLocation);
while (true)
{
const QSize previousTile = currentTile - arrowVector();
bool stopHere;
if (!isOnBoard(previousTile))
stopHere = true;
else
{
Quackle::Board::TileInformation previousTileInformation(m_board.tileInformation(previousTile.height(), previousTile.width()));
stopHere = previousTileInformation.tileType != Quackle::Board::LetterTile;
}
if (stopHere)
{
const bool horizontal = m_arrowDirection == ArrowRight;
originalMove = Quackle::Move::createPlaceMove(currentTile.height(), currentTile.width(), horizontal, hoppedTiles);
break;
}
hoppedTiles += QUACKLE_PLAYED_THRU_MARK;
currentTile = previousTile;
}
prettifyAndSetLocalCandidate(originalMove);
// TODO work some cleverness so we can do this!
//emit setCandidateMove(Quackle::Move::createNonmove());
for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
if (currentTile != tileLocation)
{
TileWidget *tile = tileAt(currentTile);
if (!tile)
continue;
tile->setArrowDirection(NoArrow);
}
prepare();
}
void GraphicalBoardFrame::appendHandler(const QString &text, bool shiftPressed)
{
if (!isOnBoard(m_arrowRoot))
return;
if (!hasCandidate())
return;
Quackle::LetterString appendedLetterString(QuackleIO::Util::encode(text));
if (appendedLetterString.length() == 0 || Quackle::String::front(appendedLetterString) < QUACKLE_FIRST_LETTER)
return;
if (shiftPressed)
appendedLetterString = Quackle::String::setBlankness(appendedLetterString);
else
appendedLetterString = Quackle::String::clearBlankness(appendedLetterString);
Quackle::Move newCandidate(m_candidate);
Quackle::LetterString newTiles(m_candidate.tiles() + appendedLetterString);
if (!m_ignoreRack && !m_rack.contains(Quackle::String::usedTiles(newTiles)))
{
Quackle::LetterString blankedNewTiles(m_candidate.tiles() + Quackle::String::setBlankness(appendedLetterString));
if (m_rack.contains(Quackle::String::usedTiles(blankedNewTiles)))
{
newTiles = blankedNewTiles;
}
}
newCandidate.setTiles(newTiles);
Quackle::LetterString hoppedTiles;
QSize currentTile(m_arrowRoot);
while (true)
{
const QSize nextTile = currentTile + arrowVector();
bool stopHere = false;
bool resetArrowAfter = false;
if (!isOnBoard(nextTile))
{
stopHere = true;
}
else
{
Quackle::Board::TileInformation nextTileInformation(m_board.tileInformation(nextTile.height(), nextTile.width()));
if (nextTileInformation.tileType != Quackle::Board::LetterTile)
stopHere = true;
}
if (stopHere)
{
newCandidate.setTiles(newCandidate.tiles() + hoppedTiles);
if (resetArrowAfter)
resetArrow();
else
m_arrowRoot = nextTile;
break;
}
hoppedTiles += QUACKLE_PLAYED_THRU_MARK;
currentTile = nextTile;
}
prettifyAndSetLocalCandidate(newCandidate);
}
void GraphicalBoardFrame::backspaceHandler()
{
unsigned int hoppedTiles = 0;
QSize currentTile(m_arrowRoot);
while (true)
{
const QSize previousTile = currentTile - arrowVector();
bool stopHere;
if (!isOnBoard(previousTile))
stopHere = true;
else
{
Quackle::Board::TileInformation previousTileInformation(m_board.tileInformation(previousTile.height(), previousTile.width()));
stopHere = previousTileInformation.tileType != Quackle::Board::LetterTile;
}
++hoppedTiles;
if (stopHere)
{
m_arrowRoot = previousTile;
break;
}
currentTile = previousTile;
}
Quackle::LetterString tiles(m_candidate.tiles());
if (hoppedTiles > tiles.length())
tiles = Quackle::LetterString();
else
tiles = Quackle::String::left(m_candidate.tiles(), m_candidate.tiles().length() - hoppedTiles);
if (tiles.empty())
{
Quackle::Move originalMove;
Quackle::LetterString hoppedLetters;
currentTile = m_arrowRoot;
while (true)
{
const QSize previousTile = currentTile - arrowVector();
bool stopHere;
if (!isOnBoard(previousTile))
stopHere = true;
else
{
Quackle::Board::TileInformation previousTileInformation(m_board.tileInformation(previousTile.height(), previousTile.width()));
stopHere = previousTileInformation.tileType != Quackle::Board::LetterTile;
}
if (stopHere)
{
const bool horizontal = m_arrowDirection == ArrowRight;
m_candidate = Quackle::Move::createPlaceMove(currentTile.height(), currentTile.width(), horizontal, hoppedLetters);
break;
}
hoppedLetters += QUACKLE_PLAYED_THRU_MARK;
currentTile = previousTile;
}
}
else
{
m_candidate.setTiles(tiles);
}
ensureCandidatePlacedProperly();
prettifyAndSetLocalCandidate(m_candidate);
}
