GameData.cpp

Go to the documentation of this file.

/* kmahjongg, the classic mahjongg game for KDE project
 *
 * Copyright (C) 1997 Mathias Mueller   <in5y158@public.uni-hamburg.de>
 * Copyright (C) 2006-2007 Mauricio Piacentini   <mauricio@tabuleiro.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. */

#include "GameData.h"

#include <KDebug>


GameData::GameData(BoardLayout *boardlayout)
{
    m_width = boardlayout->m_width;
    m_height = boardlayout->m_height;
    m_depth = boardlayout->m_depth;
    m_maxTiles = (m_width * m_height * m_depth) / 4;

    Highlight = QByteArray(m_width * m_height * m_depth, 0);
    Mask = QByteArray(m_width * m_height * m_depth, 0);
    Board = QByteArray(m_width * m_height * m_depth, 0);

    POSITION e; //constructor initializes it to 0

    MoveList = QVector<POSITION>(m_maxTiles, e);
    tilePositions = QVector<POSITION>(m_maxTiles, e);
    PosTable = QVector<POSITION>(m_maxTiles, e);
    positionDepends = QVector<DEPENDENCY>(m_maxTiles);

    //Copy board layout over
    boardlayout->copyBoardLayout((UCHAR *) getMaskBytes(), MaxTileNum);
}

GameData::~GameData()
{
}

void GameData::putTile(short e, short y, short x, UCHAR f)
{
    setBoardData(e, y, x, f);
    setBoardData(e, y + 1, x, f);
    setBoardData(e, y + 1, x + 1, f);
    setBoardData(e, y, x + 1, f);
}

bool GameData::tilePresent(int z, int y, int x)
{
    if ((y < 0) || (x < 0) || (z < 0) || (y > m_height - 1) || (x > m_width - 1)
        || (z > m_depth - 1)) {
        return false;
    }

    return (BoardData(z, y, x) != 0 && MaskData(z, y, x) == '1');
}

bool GameData::partTile(int z, int y, int x)
{
    return (BoardData(z, y, x) != 0);
}

UCHAR GameData::MaskData(short z, short y, short x)
{
    if ((y < 0) || (x < 0) || (z < 0) || (y > m_height - 1) || (x > m_width - 1)
        || (z > m_depth - 1)) {
        return 0;
    }

    return Mask.at((z * m_width * m_height) + (y * m_width) + x);
}

UCHAR GameData::HighlightData(short z, short y, short x)
{
    if ((y < 0) || (x < 0) || (z < 0) || (y > m_height - 1) || (x > m_width - 1)
        || (z > m_depth - 1)) {
        return 0;
    }

    return Highlight.at((z * m_width * m_height) + (y * m_width) + x);
}

void GameData::setHighlightData(short z, short y, short x, UCHAR value)
{
    if ((y < 0) || (x < 0) || (z < 0) || (y > m_height - 1) || (x > m_width - 1)
        || (z > m_depth - 1)) {
        return;
    }

    Highlight[(z * m_width * m_height) + (y * m_width) + x] = value;
}

UCHAR GameData::BoardData(short z, short y, short x)
{
    if ((y < 0) || (x < 0) || (z < 0) || (y > m_height - 1) || (x > m_width - 1)
        || (z > m_depth - 1)) {
        return 0;
    }

    return Board.at((z * m_width * m_height) + (y * m_width) + x);
}

void GameData::setBoardData(short z, short y, short x, UCHAR value)
{
    if ((y < 0) || (x < 0) || (z < 0) || (y > m_height - 1) || (x > m_width - 1)
        || (z > m_depth - 1)) {
        return;
    }

    Board[(z * m_width * m_height) + (y * m_width) + x] = value;
}

POSITION& GameData::MoveListData(short i)
{
    if ((i >= MoveList.size()) || (i < 0)) {
        qDebug() << "Attempt to access GameData::MoveListData with invalid index";
        i = 0 ;
    }

    return MoveList[i];
}

void GameData::setMoveListData(short i, POSITION &value)
{
    if ((i >= MoveList.size()) || (i < 0)) {
        return ;
    }

    MoveList[i] = value;
}

void GameData::generateTilePositions()
{
    // Generate the position data for the layout from contents of Game.Map.

    numTilesToGenerate = 0;

    for (int z = 0; z < m_depth; z++) {
        for (int y = 0; y < m_height; y++) {
            for (int x = 0; x < m_width; x++) {
                setBoardData(z, y, x, 0);
                if (MaskData(z,y,x) == '1') {
                    tilePositions[numTilesToGenerate].x = x;
                    tilePositions[numTilesToGenerate].y = y;
                    tilePositions[numTilesToGenerate].e = z;
                    tilePositions[numTilesToGenerate].f = 254;
                    numTilesToGenerate++;
                }
            }
        }
    }
}

void GameData::generatePositionDepends()
{
    // Generate the dependency data for the layout from the position data.
    // Note that the coordinates of each tile in tilePositions are those of
    // the upper left quarter of the tile.

    // For each tile,
    for (int i = 0; i < numTilesToGenerate; i++) {

        // Get its basic position data
        int x = tilePositions[i].x;
        int y = tilePositions[i].y;
        int z = tilePositions[i].e;

        // LHS dependencies
        positionDepends[i].lhs_dep[0] = tileAt(x - 1, y, z);
        positionDepends[i].lhs_dep[1] = tileAt(x - 1, y + 1, z);

        // Make them unique
        if (positionDepends[i].lhs_dep[1] == positionDepends[i].lhs_dep[0]) {
            positionDepends[i].lhs_dep[1] = -1;
        }

        // RHS dependencies
        positionDepends[i].rhs_dep[0] = tileAt(x + 2, y, z);
        positionDepends[i].rhs_dep[1] = tileAt(x + 2, y + 1, z);

        // Make them unique
        if (positionDepends[i].rhs_dep[1] == positionDepends[i].rhs_dep[0]) {
            positionDepends[i].rhs_dep[1] = -1;
        }

        // Turn dependencies
        positionDepends[i].turn_dep[0] = tileAt(x, y, z + 1);
        positionDepends[i].turn_dep[1] = tileAt(x + 1, y, z + 1);
        positionDepends[i].turn_dep[2] = tileAt(x + 1, y + 1, z + 1);
        positionDepends[i].turn_dep[3] = tileAt(x, y + 1, z + 1);

        // Make them unique
        for (int j = 0; j < 3; j++) {
            for (int k = j + 1; k < 4; k++) {
                if (positionDepends[i].turn_dep[j] == positionDepends[i].turn_dep[k]) {
                    positionDepends[i].turn_dep[k] = -1;
                }
            }
        }

        // Placement dependencies
        positionDepends[i].place_dep[0] = tileAt(x, y, z - 1);
        positionDepends[i].place_dep[1] = tileAt(x + 1, y, z - 1);
        positionDepends[i].place_dep[2] = tileAt(x + 1, y + 1, z - 1);
        positionDepends[i].place_dep[3] = tileAt(x, y + 1, z - 1);

        // Make them unique
        for (int j = 0; j < 3; j++) {
            for (int k = j + 1; k < 4; k++) {
                if (positionDepends[i].place_dep[j] == positionDepends[i].place_dep[k]) {
                    positionDepends[i].place_dep[k] = -1;
                }
            }
        }

        // Filled and free indicators.
        positionDepends[i].filled = false;
        positionDepends[i].free = false;
    }
}

int GameData::tileAt(int x, int y, int z)
{
    // x, y, z are the coordinates of a *quarter* tile.  This returns the
    // index (in positions) of the tile at those coordinates or -1 if there
    // is no tile at those coordinates.  Note that the coordinates of each
    // tile in positions are those of the upper left quarter of the tile.

    for (int i = 0; i < numTilesToGenerate; i++) {
        if (tilePositions[i].e == z) {
            if ((tilePositions[i].x == x && tilePositions[i].y == y)
                || (tilePositions[i].x == x - 1 && tilePositions[i].y == y)
                || (tilePositions[i].x == x - 1 && tilePositions[i].y == y - 1)
                || (tilePositions[i].x == x && tilePositions[i].y == y - 1)) {
                return i;
            }
        }
    }

    return -1;
}

bool GameData::generateSolvableGame()
{
    // Initially we want to mark positions on layer 0 so that we have only
    // one free position per apparent horizontal line.
    for (int i = 0; i < numTilesToGenerate; i++) {
        // Pick a random tile on layer 0
        int position, cnt = 0;

        do {
            position = (int) random.getLong(numTilesToGenerate);

            if (cnt++ > (numTilesToGenerate*numTilesToGenerate)) {
                return false; // bail
            }
        } while (tilePositions[position].e != 0);

        // If there are no other free positions on the same apparent
        // horizontal line, we can mark that position as free.
        if (onlyFreeInLine(position)) {
            positionDepends[position].free = true;
        }
    }

    // Check to make sure we really got them all.  Very important for
    // this algorithm.
    for (int i = 0; i < numTilesToGenerate; i++) {
        if (tilePositions[i].e == 0 && onlyFreeInLine(i)) {
            positionDepends[i].free = true;
        }
    }

    // Get ready to place the tiles
    int lastPosition = -1;
    int position = -1;
    int position2 = -1;

    // For each position,
    for (int i = 0; i < numTilesToGenerate; i++) {

        // If this is the first tile in a 144 tile set,
        if ((i % 144) == 0) {

            // Initialise the faces to allocate. For the classic
            // dragon board there are 144 tiles. So we allocate and
            // randomise the assignment of 144 tiles. If there are > 144
            // tiles we will reallocate and re-randomise as we run out.
            // One advantage of this method is that the pairs to assign are
            // non-linear. In kmahjongg 0.4, If there were > 144 the same
            // allocation series was followed. So 154 = 144 + 10 rods.
            // 184 = 144 + 40 rods (20 pairs) which overwhemed the board
            // with rods and made deadlock games more likely.
            randomiseFaces();
        }

        // If this is the first half of a pair, there is no previous
        // position for the pair.
        if ((i & 1) == 0) {
            lastPosition = -1;
        }

        // Select a position for the tile, relative to the position of
        // the last tile placed.
        if ((position = selectPosition(lastPosition)) < 0) {
            return false; // bail
        }

        if (i < numTilesToGenerate - 1) {
            if ((position2 = selectPosition(lastPosition)) < 0) {
                return false; // bail
            }
            if (tilePositions[position2].e > tilePositions[position].e) {
                position = position2;  // higher is better
            }
        }

        // Place the tile.
        placeTile(position, tilePair[i % 144]);

        // Remember the position
        lastPosition = position;
    }

    // The game is solvable.
    return true;
}

bool GameData::onlyFreeInLine(int position)
{
    // Determines whether it is ok to mark this position as "free" because
    // there are no other positions marked "free" in its apparent horizontal
    // line.

    int i, i0, w;
    int lin, rin, out;
    //static int nextLeft[m_maxTiles];
    //static int nextRight[m_maxTiles];

    QVector<int> nextLeft = QVector<int>(m_maxTiles, 0);
    QVector<int> nextRight = QVector<int>(m_maxTiles, 0);

    /* Check left, starting at position */
    lin = 0;
    out = 0;
    nextLeft[lin++] = position;

    do {
        w = nextLeft[out++];
        if (positionDepends[w].free || positionDepends[w].filled) {
            return false;
        }

        if ((i = positionDepends[w].lhs_dep[0]) != -1) {
            nextLeft[lin++] = i;
        }

        i0 = i;

        if ((i = positionDepends[w].lhs_dep[1]) != -1 && i0 != i) {
            nextLeft[lin++] = i;
        }
    } while (lin > out);

    /* Check right, starting at position */
    rin = 0;
    out = 0;
    nextRight[rin++] = position;

    do {
        w = nextRight[out++];

        if (positionDepends[w].free || positionDepends[w].filled) {
            return false;
        }

        if ((i = positionDepends[w].rhs_dep[0]) != -1) {
            nextRight[rin++] = i;
        }

        i0 = i;

        if ((i = positionDepends[w].rhs_dep[1]) != -1 && i0 != i) {
            nextRight[rin++] = i;
        }
    } while (rin > out);

    // Here, the position can be marked "free"
    return true;
}

int GameData::selectPosition(int lastPosition)
{
    int position, cnt = 0;
    bool goodPosition = false;

    // while a good position has not been found,
    while (!goodPosition) {

        // Select a random, but free, position.
        do {
            position = random.getLong(numTilesToGenerate);

            if (cnt++ > (numTilesToGenerate*numTilesToGenerate)) {
                return -1; // bail
            }
        } while (!positionDepends[position].free);

        // Found one.
        goodPosition = true;

        // If there is a previous position to take into account,
        if (lastPosition != -1) {

            // Check the new position against the last one.
            for (int i = 0; i < 4; i++) {
                if (positionDepends[position].place_dep[i] == lastPosition) {
                    goodPosition = false;  // not such a good position
                }
            }

            for (int i = 0; i < 2; i++) {
                if ((positionDepends[position].lhs_dep[i] == lastPosition)
                    || (positionDepends[position].rhs_dep[i] == lastPosition)) {
                    goodPosition = false;  // not such a good position
                }
            }
        }
    }

    return position;
}

void GameData::placeTile(int position, int tile)
{
    // Install the tile in the specified position
    tilePositions[position].f = tile;
    putTile(tilePositions[position]);

    //added highlight?
    //setHighlightData(E,Y,X,0);

    // Update position dependency data
    positionDepends[position].filled = true;
    positionDepends[position].free = false;

    // Now examine the tiles near this to see if this makes them "free".
    int depend;

    for (int i = 0; i < 4; i++) {
        if ((depend = positionDepends[position].turn_dep[i]) != -1) {
            updateDepend(depend);
        }
    }

    for (int i = 0; i < 2; i++) {
        if ((depend = positionDepends[position].lhs_dep[i]) != -1) {
            updateDepend(depend);
        }

        if ((depend = positionDepends[position].rhs_dep[i]) != -1) {
            updateDepend(depend);
        }
    }
}

void GameData::updateDepend(int position)
{
    // Updates the free indicator in the dependency data for a position
    // based on whether the positions on which it depends are filled.

    // If the position is valid and not filled
    if (position >= 0 && !positionDepends[position].filled) {

        // Check placement depends.  If they are not filled, the
        // position cannot become free.
        int depend;
        for (int i = 0; i < 4; i++) {
            if ((depend = positionDepends[position].place_dep[i]) != -1) {
                if (!positionDepends[depend].filled) {
                    return ;
                }
            }
        }

        // If position is first free on apparent horizontal, it is
        // now free to be filled.
        if (onlyFreeInLine(position)) {
            positionDepends[position].free = true;

            return;
        }

        // Assume no LHS positions to fill
        bool lfilled = false;

          // If positions to LHS
        if ((positionDepends[position].lhs_dep[0] != -1)
            || (positionDepends[position].lhs_dep[1] != -1)) {

            // Assume LHS positions filled
            lfilled = true;

            for (int i = 0; i < 2; i++) {
                if ((depend = positionDepends[position].lhs_dep[i]) != -1) {
                    if (!positionDepends[depend].filled) {
                         lfilled = false;
                    }
                }
            }
        }

        // Assume no RHS positions to fill
        bool rfilled = false;

          // If positions to RHS
        if ((positionDepends[position].rhs_dep[0] != -1)
            || (positionDepends[position].rhs_dep[1] != -1)) {

            // Assume LHS positions filled
            rfilled = true;

            for (int i = 0; i < 2; i++) {
                if ((depend = positionDepends[position].rhs_dep[i]) != -1) {
                    if (!positionDepends[depend].filled) {
                        rfilled = false;
                    }
                }
            }
        }

        // If positions to left or right are filled, this position
        // is now free to be filled.
        positionDepends[position].free = (lfilled || rfilled);
    }
}

bool GameData::generateStartPosition2()
{
    // For each tile,
    for (int i = 0; i < numTilesToGenerate; i++) {

        // Get its basic position data
        int x = tilePositions[i].x;
        int y = tilePositions[i].y;
        int z = tilePositions[i].e;

        // Clear Game.Board at that position
        setBoardData(z, y, x, 0);

        // Clear tile placed/free indicator(s).
        positionDepends[i].filled = false;
        positionDepends[i].free = false;

        // Set tile face blank
        tilePositions[i].f = 254;
    }

    // If solvable games should be generated,
//     if (Prefs::solvableGames()) {

    if (generateSolvableGame()) {
        TileNum = MaxTileNum;
        return true;
    } else {
        return false;
    }

//     }

    // Initialise the faces to allocate. For the classic
    // dragon board there are 144 tiles. So we allocate and
    // randomise the assignment of 144 tiles. If there are > 144
    // tiles we will reallocate and re-randomise as we run out.
    // One advantage of this method is that the pairs to assign are
    // non-linear. In kmahjongg 0.4, If there were > 144 the same
    // allocation series was followed. So 154 = 144 + 10 rods.
    // 184 = 144 + 40 rods (20 pairs) which overwhemed the board
    // with rods and made deadlock games more likely.

    int remaining = numTilesToGenerate;
    randomiseFaces();

    for (int tile = 0; tile < numTilesToGenerate; tile += 2) {
        int p1;
        int p2;

        if (remaining > 2) {
            p2 = p1 = random.getLong(remaining - 2);
            int bail = 0;

            while (p1 == p2) {
                p2 = random.getLong(remaining - 2);

                if (bail >= 100) {
                    if (p1 != p2) {
                        break;
                    }
                }

                if ((tilePositions[p1].y == tilePositions[p2].y)
                    && (tilePositions[p1].e == tilePositions[p2].e)) {
                    // skip if on same y line
                    bail++;
                    p2=p1;

                    continue;
                }
            }
        } else {
            p1 = 0;
            p2 = 1;
        }

        POSITION a;
        POSITION b;

        a = tilePositions[p1];
        b = tilePositions[p2];

        tilePositions[p1] = tilePositions[remaining - 1];
        tilePositions[p2] = tilePositions[remaining - 2];

        remaining -= 2;

        getFaces(a, b);
        putTile(a);
        putTile(b);
    }

    TileNum = MaxTileNum;

    return 1;
}

void GameData::getFaces(POSITION &a, POSITION &b)
{
    a.f = tilePair[tilesUsed];
    b.f = tilePair[tilesUsed + 1];
    tilesUsed += 2;

    if (tilesUsed >= 144) {
        randomiseFaces();
    }
}

void GameData::randomiseFaces()
{
    int nr;
    int numAlloced = 0;
    // stick in 144 tiles in pairsa.

    for (nr = 0; nr < 9 * 4; ++nr) {
        tilePair[numAlloced++] = TILE_CHARACTER + (nr / 4); // 4*9 Tiles
    }

    for (nr = 0; nr < 9 * 4; ++nr) {
        tilePair[numAlloced++] = TILE_BAMBOO + (nr / 4); // 4*9 Tiles
    }

    for (nr = 0; nr < 9 * 4; ++nr) {
        tilePair[numAlloced++] = TILE_ROD + (nr / 4); // 4*9 Tiles
    }

    for (nr = 0; nr < 4; ++nr) {
        tilePair[numAlloced++] = TILE_FLOWER + nr; // 4 Tiles
    }

    for (nr = 0; nr < 4; ++nr) {
        tilePair[numAlloced++] = TILE_SEASON + nr; // 4 Tiles
    }

    for (nr = 0; nr < 4 * 4; ++nr) {
        tilePair[numAlloced++] = TILE_WIND + (nr / 4); // 4*4 Tiles
    }

    for (nr = 0; nr < 3 * 4; ++nr) {
        tilePair[numAlloced++] = TILE_DRAGON + (nr / 4); // 3*4 Tiles
    }

    //randomise. Keep pairs together. Ie take two random
    //odd numbers (n,x) and swap n, n+1 with x, x+1

    int at = 0;
    int to = 0;
    for (int r = 0; r < 200; r++) {
        to = at;

        while (to==at) {
            to = random.getLong(144);

            if ((to & 1) != 0) {
                to--;
            }

        }

        UCHAR tmp = tilePair[at];
        tilePair[at] = tilePair[to];
        tilePair[to] = tmp;
        tmp = tilePair[at + 1];
        tilePair[at + 1] = tilePair[to + 1];
        tilePair[to + 1] = tmp;

        at += 2;

        if (at >= 144) {
            at = 0;
        }
    }

    tilesAllocated = numAlloced;
    tilesUsed = 0;
}

bool isFlower(UCHAR Tile)
{
    return (Tile >= TILE_FLOWER  &&  Tile <=TILE_FLOWER + 3);
}

bool isSeason(UCHAR Tile)
{
    return (Tile >= TILE_SEASON  &&  Tile <= TILE_SEASON + 3);
}

bool isBamboo(UCHAR t)
{
    return (t >= TILE_BAMBOO && t < TILE_BAMBOO + 9);
}

bool isCharacter(UCHAR t)
{
    return (t < TILE_CHARACTER + 9);
}

bool isRod(UCHAR t)
{
    return (t >= TILE_ROD && t < TILE_ROD + 9);
}

bool isDragon(UCHAR t)
{
    return (t >= TILE_DRAGON && t < TILE_DRAGON + 3);
}

bool isWind(UCHAR t)
{
    return (t >= TILE_WIND && t < TILE_WIND + 4);
}

bool GameData::isMatchingTile(POSITION &Pos1, POSITION &Pos2)
{
    // don't compare 'equal' positions
    if (memcmp(&Pos1, &Pos2, sizeof(POSITION))) {
        UCHAR FA = Pos1.f;
        UCHAR FB = Pos2.f;

        if ((FA == FB) || (isFlower(FA) && isFlower(FB)) || (isSeason(FA) && isSeason(FB))) {
            return true;
        }
    }

    return false;
}

void GameData::setRemovedTilePair(POSITION &a, POSITION &b)
{
    if (isFlower(a.f)) {
        removedFlower[a.f - TILE_FLOWER]++;
        removedFlower[b.f - TILE_FLOWER]++;

        return;
    }

    if (isSeason(a.f)) {
        removedSeason[a.f - TILE_SEASON]++;
        removedSeason[b.f - TILE_SEASON]++;

        return;
    }

    if (isCharacter(a.f)) {
        removedCharacter[a.f - TILE_CHARACTER] += 2;

        return;
    }

    if (isBamboo(a.f)) {
        removedBamboo[a.f - TILE_BAMBOO] += 2;

        return;
    }

    if (isRod(a.f)) {
        removedRod[a.f - TILE_ROD] += 2;

        return;
    }

    if (isDragon(a.f)){
        removedDragon[a.f - TILE_DRAGON] += 2;

        return;
    }

    if (isWind(a.f)){
        removedWind[a.f - TILE_WIND] += 2;

        return;
    }
}

void GameData::clearRemovedTilePair(POSITION &a, POSITION &b)
{
    if (isFlower(a.f)) {
        removedFlower[a.f - TILE_FLOWER]--;
        removedFlower[b.f - TILE_FLOWER]--;

        return;
    }

    if (isSeason(a.f)) {
        removedSeason[a.f - TILE_SEASON]--;
        removedSeason[b.f - TILE_SEASON]--;

        return;
    }

    if (isCharacter(a.f)) {
        removedCharacter[a.f - TILE_CHARACTER] -= 2;

        return;
    }

    if (isBamboo(a.f)) {
        removedBamboo[a.f - TILE_BAMBOO] -= 2;

        return;
    }

    if (isRod(a.f)) {
        removedRod[a.f - TILE_ROD] -= 2;

        return;
    }

    if (isDragon(a.f)) {
        removedDragon[a.f - TILE_DRAGON] -= 2;

        return;
    }

    if (isWind(a.f)) {
        removedWind[a.f - TILE_WIND] -= 2;

        return;
    }
}

void GameData::initialiseRemovedTiles()
{
    for (int pos = 0; pos < 9; pos++) {
        removedCharacter[pos] = 0;
        removedBamboo[pos] = 0;
        removedRod[pos] = 0;
        removedDragon[pos % 3] = 0;
        removedFlower[pos % 4] = 0;
        removedWind[pos % 4] = 0;
        removedSeason[pos % 4] = 0;
    }
}

bool GameData::findMove(POSITION &posA, POSITION &posB)
{
    short Pos_Ende = MaxTileNum;  // Ende der PosTable

    for (short E = 0; E < m_depth; E++) {
        for (short Y = 0; Y < m_height - 1; Y++) {
            for (short X = 0; X < m_width - 1; X++) {
                if (MaskData(E, Y, X) != (UCHAR) '1') {
                    continue;
                }

                if (!BoardData(E, Y, X)) {
                    continue;
                }

                if (E < m_depth - 1) {
                    if (BoardData(E + 1, Y, X) || BoardData(E + 1, Y + 1, X)
                        || BoardData(E + 1, Y, X + 1) || BoardData(E + 1, Y + 1, X + 1)) {
                        continue;
                    }
                }

                if (X < m_width - 2 && (BoardData(E, Y, X - 1) || BoardData(E, Y + 1, X - 1))
                    && (BoardData(E, Y, X + 2) || BoardData(E, Y + 1, X + 2))) {
                    continue;
                }

                Pos_Ende--;
                PosTable[Pos_Ende].e = E;
                PosTable[Pos_Ende].y = Y;
                PosTable[Pos_Ende].x = X;
                PosTable[Pos_Ende].f = BoardData(E, Y, X);
            }
        }
    }

    short iPosCount = 0;  // Hier Anzahl der gefunden Paare merken

    // The new tile layout with non-contiguos horizantle spans
    // can lead to huge numbers of matching pairs being exposed.
    // we alter the loop to bail out when BoardLayout::maxTiles/2 pairs are found
    // (or less);
    while (Pos_Ende < MaxTileNum - 1 && iPosCount < m_maxTiles - 2) {
        for (short Pos = Pos_Ende + 1; Pos < MaxTileNum; Pos++) {
            if (isMatchingTile(PosTable[Pos], PosTable[Pos_Ende])) {
                if (iPosCount < m_maxTiles - 2) {
                    PosTable[iPosCount++] = PosTable[Pos_Ende];
                    PosTable[iPosCount++] = PosTable[Pos];
                }
            }
        }

        Pos_Ende++;
    }

    if (iPosCount >= 2) {
        random.setSeed(0); // WABA: Why is the seed reset?
        short Pos = random.getLong(iPosCount) & -2;  // Gerader Wert
        posA = PosTable[Pos];
        posB = PosTable[Pos + 1];

        return true;
    } else {
        return false;
    }
}

int GameData::moveCount()
{
    short Pos_Ende = MaxTileNum;  // end of PosTable

    for (short E = 0; E < m_depth; E++) {
        for (short Y = 0; Y < m_height - 1; Y++) {
            for (short X = 0; X < m_width - 1; X++) {
                if (MaskData(E, Y, X) != (UCHAR) '1') {
                    continue;
                }

                if (!BoardData(E, Y, X)) {
                    continue;
                }

                if (E < m_depth - 1) {
                    if (BoardData(E + 1, Y, X) || BoardData(E + 1, Y + 1,X)
                        || BoardData(E + 1, Y, X + 1) || BoardData(E + 1, Y + 1, X + 1)) {
                        continue;
                    }
                }

                if (X < m_width - 2 && (BoardData(E, Y, X - 1) || BoardData(E, Y + 1, X - 1))
                    && (BoardData(E, Y, X + 2) || BoardData(E, Y + 1, X + 2))) {
                    continue;
                }

                Pos_Ende--;
                PosTable[Pos_Ende].e = E;
                PosTable[Pos_Ende].y = Y;
                PosTable[Pos_Ende].x = X;
                PosTable[Pos_Ende].f = BoardData(E, Y, X);
            }
        }
    }

    short iPosCount = 0;  // store number of pairs found

    while (Pos_Ende < MaxTileNum - 1 && iPosCount < m_maxTiles - 2) {
        for (short Pos = Pos_Ende + 1; Pos < MaxTileNum; Pos++) {
            if (isMatchingTile(PosTable[Pos], PosTable[Pos_Ende])) {
                if (iPosCount < m_maxTiles - 2) {
                    PosTable[iPosCount++] = PosTable[Pos_Ende];
                    PosTable[iPosCount++] = PosTable[Pos];
                }
            }
        }

        Pos_Ende++;
    }

    return iPosCount / 2;
}

short GameData::findAllMatchingTiles(POSITION &posA)
{
    short Pos = 0;

    for (short E = 0; E < m_depth; E++) {
        for (short Y = 0; Y < m_height - 1; Y++) {
            for (short X = 0; X < m_width - 1; X++) {
                if (MaskData(E, Y, X) != (UCHAR) '1') {
                    continue;
                }

                if (!BoardData(E, Y, X)) {
                    continue;
                }

                if (E < m_depth - 1) {
                    if (BoardData(E + 1, Y, X) || BoardData(E + 1, Y + 1, X)
                        || BoardData(E + 1, Y, X + 1) || BoardData(E + 1, Y + 1, X + 1)) {
                        continue;
                    }
                }

                if (X < m_width - 2 && (BoardData(E, Y, X - 1) || BoardData(E, Y + 1, X - 1))
                    && (BoardData(E, Y, X + 2) || BoardData(E, Y + 1, X + 2))) {
                    continue;
                }

                PosTable[Pos].e = E;
                PosTable[Pos].y = Y;
                PosTable[Pos].x = X;
                PosTable[Pos].f = BoardData(E, Y, X);

                if (isMatchingTile(posA, PosTable[Pos])) {
                    Pos++;
                }
            }
        }
    }

    return Pos;
}

bool GameData::loadFromStream(QDataStream &in)
{
    in >> Board;
    in >> Mask;
    in >> Highlight;
    in >> allow_undo;
    in >> allow_redo;
    in >> TileNum;
    in >> MaxTileNum;

    //Read list count
    in >> m_maxTiles;

    //Reconstruct the MoveList
    for (int i = 0; i < m_maxTiles; ++i) {
        POSITION thispos;
        in >> thispos.e;
        in >> thispos.y;
        in >> thispos.x;
        in >> thispos.f;
        setMoveListData(i, thispos);
    }

    return true;
}

bool GameData::saveToStream(QDataStream &out)
{
    out << Board;
    out << Mask;
    out << Highlight;
    out << allow_undo;
    out << allow_redo;
    out << TileNum;
    out << MaxTileNum;

    //write the size of our lists
    out << m_maxTiles;

    //and then write all position components for the MoveList
    for (int i = 0; i < m_maxTiles; ++i) {
        POSITION thispos = MoveList.at(i);
        out << (quint16) thispos.e;
        out << (quint16) thispos.y;
        out << (quint16) thispos.x;
        out << (quint16) thispos.f;
    }

    return true;
}

void GameData::shuffle()
{
    int count = 0;

    // copy positions and faces of the remaining tiles into
    // the pos table
    for (int e = 0; e < m_depth; e++) {
        for (int y = 0; y < m_height; y++) {
            for (int x = 0; x < m_width; x++) {
                if (BoardData(e, y, x) && MaskData(e, y, x) == '1') {
                    PosTable[count].e = e;
                    PosTable[count].y = y;
                    PosTable[count].x = x;
                    PosTable[count].f = BoardData(e, y, x);
                    count++;
                }
            }
        }
    }

    // now lets randomise the faces, selecting 400 pairs at random and
    // swapping the faces.
    for (int ran = 0; ran < 400; ran++) {
        int pos1 = random.getLong(count);
        int pos2 = random.getLong(count);

        if (pos1 == pos2) {
            continue;
        }

        BYTE f = PosTable[pos1].f;
        PosTable[pos1].f = PosTable[pos2].f;
        PosTable[pos2].f = f;
    }

    // put the rearranged tiles back.
    for (int p = 0; p < count; p++) {
        putTile(PosTable[p]);
    }
}