source: trunk/monsterz/board.cpp @ 752 Tweet

//
// Monsterz
//
// Copyright: (c) 2005-2011 Sam Hocevar <sam@hocevar.net>
//   This program is free software; you can redistribute it and/or
//   modify it under the terms of the Do What The Fuck You Want To
//   Public License, Version 2, as published by Sam Hocevar. See
//   http://sam.zoy.org/projects/COPYING.WTFPL for more details.
//

#if defined HAVE_CONFIG_H
#   include "config.h"
#endif

#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>

#include "core.h"

using namespace lol;

#include "board.h"
#include "piece.h"
#include "score.h"
#include "thumbs.h"
#include "mash.h"
#include "monsterz.h"

/*
 * Board implementation class
 */

class BoardData
{
    friend class Board;

private:
    Board::game_t game;

    vec2i dim, size;
    int minnpieces, npieces, maxnpieces;

    int screen, board, tiles, icons;
    int click, whip;

    struct Pair
    {
        int id;
        Piece *piece;
    }
    pairs[MAX_WIDTH][MAX_HEIGHT];

    /* Hunt */
    struct Pair grabbed;
    int nmoves;
    vec2i src_cell, dst_cell;

    /* Fusion */
    struct Pair current[2];
    int next[2], rotation;

    Score *score;

    Mash *mashes;
    Emitter *emitter;
    Thumbs *thumbs;

    vec2i oldmouse;
    vec3i oldbuttons;
    float whipdelay;

    enum
    {
        HUNT_IDLE,
        HUNT_BADCLICK,
        HUNT_GRAB,
        FUSION_IDLE,
    }
    state;
};

/*
 * Public Board class
 */

Board::Board(game_t game, vec2i dim, int minnpieces, int maxnpieces)
  : data(new BoardData())
{
    data->game = game;

    switch (data->game)
    {
    case GAME_HUNT:
        data->size = 48;
        break;
    case GAME_FUSION:
        data->size = 40;
        break;
    }

    data->dim = dim;
    data->minnpieces = minnpieces;
    data->npieces = minnpieces;
    data->maxnpieces = maxnpieces;
    data->screen = Tiler::Register(PNG_BACKGROUND, vec2i(640, 480), 0, 1.0f);
    data->board = Tiler::Register(PNG_BOARD, 384, 0, 1.0f);
    data->tiles = Tiler::Register(PNG_TILES, data->size, 0, 1.0f);
    data->icons = Tiler::Register(PNG_ICONS, 24, 0, 1.0f);
    data->click = Sampler::Register(WAV_CLICK);
    data->whip = Sampler::Register(WAV_WHIP);

    data->emitter = new Emitter(data->tiles, vec3(0, -0.0006f, 0));
    Ticker::Ref(data->emitter);

    data->thumbs = new Thumbs(0);
    Ticker::Ref(data->thumbs);

    switch (data->game)
    {
    case GAME_HUNT:
        Fill();
        data->thumbs->SetMax(data->npieces);
        data->state = BoardData::HUNT_IDLE;
        break;

    case GAME_FUSION:
        for (int j = 0; j < data->dim.j; j++)
            for (int i = 0; i < data->dim.i; i++)
                data->pairs[i][j].id = 0;

        data->current[0].id = GetRandomId();
        data->current[1].id = GetRandomId();
        data->current[0].piece = new Piece(Piece::PIECE_FUSION,
                                           data->emitter, vec2i(3, 8),
                                           data->current[0].id);
        data->current[1].piece = new Piece(Piece::PIECE_FUSION,
                                           data->emitter, vec2i(4, 8),
                                           data->current[1].id);
        Ticker::Ref(data->current[0].piece);
        Ticker::Ref(data->current[1].piece);
        data->current[0].piece->SetPos(vec2i(3, 7) * data->size);
        data->current[1].piece->SetPos(vec2i(4, 7) * data->size);

        data->next[0] = GetRandomId();
        data->next[1] = GetRandomId();
        data->rotation = 0;

        data->thumbs->SetMax(data->npieces + 1);
        data->state = BoardData::FUSION_IDLE;
        break;
    }

    data->mashes = NULL;
    data->whipdelay = 0.0f;

    data->score = new Score(0);
    data->score->SetPos(vec3i(624, 432, 20));
    Ticker::Ref(data->score);

    position = vec3i(24, 72, 1);
    bbox[0] = position;
    bbox[1] = bbox[0] + vec3i(384, 384, 0);

    Input::TrackMouse(this);
}

void Board::TickGame(float deltams)
{
    Entity::TickGame(deltams);

    vec3i buttons = Input::GetMouseButtons();

    /* Do not whip too often, the sound may become annoying */
    data->whipdelay -= deltams;

    /* Get rid of finished mashes */
    for (Mash **it = &data->mashes; *it; )
    {
        if ((*it)->IsDead())
        {
            Ticker::Unref(*it);
            *it = (*it)->nextmash;
        }
        else
            it = &(*it)->nextmash;
    }

    switch (data->state)
    {
    case BoardData::HUNT_IDLE:
        /* Should we start dragging something? */
        if (buttons[0] && !data->oldbuttons[0] && mousepos.x != -1)
        {
            vec2i cell = mousepos / data->size;
            if (data->pairs[cell.x][cell.y].piece->Grab(vec2i(0, 0)))
            {
                Sampler::PlaySample(data->click);
                data->grabbed = data->pairs[cell.x][cell.y];
                data->src_cell = mousepos / data->size;
                data->dst_cell = vec2i(-1);
                data->state = BoardData::HUNT_GRAB;
            }
            else
                data->state = BoardData::HUNT_BADCLICK;
        }
        break;

    case BoardData::HUNT_GRAB:
        if (mousepos.x != -1)
        {
            /* Mouse is still in the window, keep grabbing */
            data->grabbed.piece->Grab(mousepos - data->oldmouse);
            vec2i cur_pos = data->grabbed.piece->GetPos()
                          + data->grabbed.piece->GetOffset();
            vec2i cur_cell = (cur_pos + data->size / 2) / data->size;
            if (cur_cell.i < 0 || cur_cell.i >= data->dim.i
                 || cur_cell.j < 0 || cur_cell.j >= data->dim.j
                 || (cur_pos - cur_cell * data->size).sqlen() > data->size.sqlen() / 8
                 || (cur_cell - data->src_cell).sqlen() != 1)
                cur_cell = vec2i(-1);
            /* If potential target changed, update our cache. */
            if (cur_cell != data->dst_cell)
            {
                if (data->whipdelay < 0.0f)
                {
                    Sampler::PlaySample(data->whip);
                    data->whipdelay = DELAY_WHIP;
                }
                if (data->dst_cell != vec2i(-1))
                    data->pairs[data->dst_cell.i]
                               [data->dst_cell.j].piece->Ungrab(data->dst_cell * data->size);
                if (cur_cell != vec2i(-1))
                    data->pairs[cur_cell.i]
                               [cur_cell.j].piece->Ungrab(data->src_cell * data->size);
                data->dst_cell = cur_cell;
            }
        }

        /* Move initiated: if valid, perform immediately. */
        if (data->dst_cell != vec2i(-1))
        {
            vec2i cell_a = data->src_cell;
            vec2i cell_b = data->dst_cell;

            if (Switch(cell_a, cell_b))
                data->state = BoardData::HUNT_IDLE;
        }

        /* Mouse released, or exited window, or dragged too far. */
        if (!buttons[0] || mousepos.x == -1
             || (data->src_cell * data->size - data->grabbed.piece->GetPos()
                  - data->grabbed.piece->GetOffset()).sqlen() > 100 * 100)
        {
            vec2i cell_a = data->src_cell;
            BoardData::Pair a = data->pairs[cell_a.i][cell_a.j];
            a.piece->Ungrab(cell_a * data->size);

            if (data->dst_cell != vec2i(-1))
            {
                vec2i cell_b = data->dst_cell;
                BoardData::Pair b = data->pairs[cell_b.i][cell_b.j];
                b.piece->Ungrab(cell_b * data->size);
            }

            data->state = BoardData::HUNT_IDLE;
        }
        break;

    case BoardData::HUNT_BADCLICK:
        if (!buttons[0])
            data->state = BoardData::HUNT_IDLE;
        break;

    case BoardData::FUSION_IDLE:
    {
        int column = -1;

        if (clicked[2])
        {
            column = data->current[0].piece->GetCell().x;
            data->rotation = (data->rotation + 1) % 2;
            if (column - data->rotation > data->dim.i - 1)
                column = data->dim.i - 1 - data->rotation;
            if (!data->rotation)
            {
                BoardData::Pair tmp = data->current[0];
                data->current[0] = data->current[1];
                data->current[1] = tmp;
                if (column == data->dim.i - 1)
                    column = 6;
            }
        }

        if (mousepos.x != -1 &&
            mousepos.x / data->size.x != data->current[0].piece->GetCell().x)
        {
            column = mousepos.x / data->size.x;
            column = column < 0 ? 0 : column > data->dim.i - 2 + data->rotation ? data->dim.i - 2 + data->rotation : column;
        }

        if (column != -1)
        {
            if (data->rotation)
            {
                data->current[0].piece->SetCell(vec2i(column, 6));
                data->current[1].piece->SetCell(vec2i(column, 7));
            }
            else
            {
                data->current[0].piece->SetCell(vec2i(column, 7));
                data->current[1].piece->SetCell(vec2i(column + 1, 7));
            }

            data->current[0].piece->Move(data->current[0].piece->GetCell() * data->size);
            data->current[1].piece->Move(data->current[1].piece->GetCell() * data->size);
        }

        if (clicked[0])
        {
            for (int t = 0; t < 2; t++)
            {
                int i = data->current[t].piece->GetCell().i;
                for (int j = 0; j < 7; j++)
                    if (data->pairs[i][j].id == 0)
                    {
                        data->current[t].piece->SetCell(vec2i(i, j));
                        data->current[t].piece->Move(vec2i(i, j) * data->size);
                        data->pairs[i][j] = data->current[t];
                        data->thumbs->AddCount(data->current[t].id, 1);
                        break;
                    }
            }

            data->current[0].id = data->next[0];
            data->current[1].id = data->next[1];
            data->current[0].piece = new Piece(Piece::PIECE_FUSION,
                                               data->emitter, vec2i(3, 7),
                                               data->current[0].id);
            data->current[1].piece = new Piece(Piece::PIECE_FUSION,
                                               data->emitter, vec2i(4, 7),
                                               data->current[1].id);
            Ticker::Ref(data->current[0].piece);
            Ticker::Ref(data->current[1].piece);
            data->current[0].piece->SetPos(vec2i(3, 8) * data->size);
            data->current[1].piece->SetPos(vec2i(4, 8) * data->size);
            data->current[0].piece->Move(data->current[0].piece->GetCell() * data->size);
            data->current[1].piece->Move(data->current[1].piece->GetCell() * data->size);
            data->next[0] = GetRandomId();
            data->next[1] = GetRandomId();
            data->rotation = 0;

            Resolve();
        }
        break;
    }
    }

    data->oldmouse = mousepos;
    data->oldbuttons = buttons;
}

void Board::TickDraw(float deltams)
{
    Entity::TickDraw(deltams);

    Scene::GetDefault()->AddTile((data->board << 16) | 0,
                                 position.x, position.y, 1, 0);
    Scene::GetDefault()->AddTile((data->screen << 16) | 0, 0, 0, 10, 0);

    switch (data->game)
    {
    case GAME_HUNT:
        break;
    case GAME_FUSION:
        Scene::GetDefault()->AddTile((data->icons << 16) | (data->next[0] - 1),
                                     350, 400, 11, 0);
        Scene::GetDefault()->AddTile((data->icons << 16) | (data->next[1] - 1),
                                     380, 400, 11, 0);
        break;
    }
}

/* Fill the board with an initial position. We ensure no pieces are
 * aligned and at least one move is possible. */
void Board::Fill()
{
    srand(rand() ^ time(NULL));

    int list[MAX_WIDTH][MAX_HEIGHT];
    do
    {
        for (int j = 0; j < data->dim.j; j++)
            for (int i = 0; i < data->dim.i; i++)
                data->pairs[i][j].id = 1 + rand() % data->npieces;
    } while (ListMashes(list) || !(data->nmoves = ListMoves(list)));

    /* Spawn pieces */
    for (int j = 0; j < data->dim.j; j++)
        for (int i = 0; i < data->dim.i; i++)
        {
            vec2i newpos = vec2i(i, j + data->dim.j) * data->size;
            int id = data->pairs[i][j].id;
            data->pairs[i][j].piece = new Piece(Piece::PIECE_HUNT,
                                                data->emitter, vec2i(i, j), id);
            data->pairs[i][j].piece->SetPos(newpos);
            data->pairs[i][j].piece->Move(vec2i(i, j) * data->size);
            if (j)
                data->pairs[i][j].piece->SetBelow(data->pairs[i][j - 1].piece);
            Ticker::Ref(data->pairs[i][j].piece);
        }
}

bool Board::Switch(vec2i cell_a, vec2i cell_b)
{
    BoardData::Pair a = data->pairs[cell_a.i][cell_a.j];
    BoardData::Pair b = data->pairs[cell_b.i][cell_b.j];
    data->pairs[cell_a.i][cell_a.j] = b;
    data->pairs[cell_b.i][cell_b.j] = a;

    /* Check whether this is a valid move by testing all patterns.
     * If the move is invalid, cancel the swap and bail out */
    int list[MAX_WIDTH][MAX_HEIGHT];

    if (!ListMashes(list))
    {
        data->pairs[cell_a.i][cell_a.j] = a;
        data->pairs[cell_b.i][cell_b.j] = b;
        return false;
    }

    /* Perform the swap */
    a.piece->SetCell(cell_b);
    a.piece->Ungrab(cell_b * data->size);
    b.piece->SetCell(cell_a);
    b.piece->Ungrab(cell_a * data->size);

    /* Swap above and below cells */
    if (cell_a.i == cell_b.i)
    {
        Piece *tmpa = a.piece->GetAbove();
        Piece *tmpb = b.piece->GetAbove();
        if (tmpb == a.piece)
        {
            tmpb = b.piece->GetBelow();
            b.piece->SetAbove(tmpa);
            b.piece->SetBelow(a.piece);
            a.piece->SetBelow(tmpb);
        }
        else /* tmpa == b.piece */
        {
            tmpa = a.piece->GetBelow();
            a.piece->SetAbove(tmpb);
            a.piece->SetBelow(b.piece);
            b.piece->SetBelow(tmpa);
        }
    }
    else
    {
        Piece *tmpa = a.piece->GetAbove();
        Piece *tmpb = b.piece->GetAbove();
        a.piece->SetAbove(tmpb);
        b.piece->SetAbove(tmpa);
        tmpa = a.piece->GetBelow();
        tmpb = b.piece->GetBelow();
        a.piece->SetBelow(tmpb);
        b.piece->SetBelow(tmpa);
    }

    int multiplier = 20;

    /* Remove matching pieces and store them in Mash objects */
    do
    {
        Mash *mash = new Mash(data->emitter);
        Ticker::Ref(mash);

        for (int j = data->dim.j; j--;) for (int i = 0; i < data->dim.i; i++)
        {
            if (!list[i][j])
                continue;

            /* The mash becomes the new owner of the disappearing piece */
            mash->AddPiece(data->pairs[i][j].piece);
            data->thumbs->AddCount(data->pairs[i][j].id, 1);

#if 0 // Test for piece creation
            if (list[i][j] >= 2)
            {
                Piece *old = data->pairs[i][j].piece;
                int id = 1 + rand() % data->npieces;
                data->pairs[i][j].id = id;
                data->pairs[i][j].piece = new Piece(Piece::PIECE_HUNT, data->emitter, vec2i(i, j), id);
                data->pairs[i][j].piece->SetBelow(old->GetBelow());
                data->pairs[i][j].piece->SetAbove(old->GetAbove());
                Ticker::Ref(data->pieces[i][j].piece);
                list[i][j] = 0;
            }
            else
#endif
            {
                Piece *below = data->pairs[i][data->dim.j - 1].piece;

                /* Change coordinates for the whole column above */
                for (int j2 = j + 1; j2 < data->dim.j; j2++)
                {
                    data->pairs[i][j2 - 1] = data->pairs[i][j2];
                    data->pairs[i][j2 - 1].piece->SetCell(vec2i(i, j2 - 1));
                    data->pairs[i][j2 - 1].piece->Move(vec2i(i, j2 - 1) * data->size);
                    list[i][j2 - 1] = list[i][j2];
                }

                /* Spawn a new piece above all the others and attach it to
                 * the board. */
                vec2i newpos = vec2i(i * data->size.x,
                                     below->GetPos().y + data->size.y);
                vec2i newcell = vec2i(i, data->dim.j - 1);
                int id = 1 + rand() % data->npieces;
                Piece *tmp = new Piece(Piece::PIECE_HUNT, data->emitter,
                                       newcell, id);
                tmp->SetBelow(below);
                tmp->SetPos(newpos);
                tmp->Move(newcell * data->size);
                Ticker::Ref(tmp);
                data->pairs[i][data->dim.j - 1].id = id;
                data->pairs[i][data->dim.j - 1].piece = tmp;
                list[i][data->dim.j - 1] = 0;
            }
        }

        mash->nextmash = data->mashes;
        data->mashes = mash;

        data->score->Add(multiplier);
        multiplier *= 2;
    }
    while(ListMashes(list));

    data->nmoves = ListMoves(list);

    if (data->nmoves == 0)
    {
        Mash *mash = new Mash(data->emitter);
        Ticker::Ref(mash);

        for (int j = data->dim.j; j--;) for (int i = 0; i < data->dim.i; i++)
            mash->AddPiece(data->pairs[i][j].piece);

        mash->nextmash = data->mashes;
        data->mashes = mash;

        Piece *below[MAX_WIDTH];
        for (int i = 0; i < data->dim.i; i++)
            below[i] = data->pairs[i][data->dim.j - 1].piece;

        Fill();

        for (int i = 0; i < data->dim.i; i++)
            data->pairs[i][0].piece->SetBelow(below[i]);
    }

    return true;
}

/* Fill an array with the list of pieces that should disappear due to
 * 3-piece or more alignments. */
int Board::ListMashes(int list[MAX_WIDTH][MAX_HEIGHT])
{
    int ret = 0;

    for (int j = 0; j < data->dim.j; j++)
        for (int i = 0; i < data->dim.i; i++)
            list[i][j] = 0;

    for (int j = 0; j < data->dim.j; j++)
        for (int i = 0; i < data->dim.i; i++)
        {
            int id = data->pairs[i][j].id;

            if (i + 2 < data->dim.i && data->pairs[i + 1][j].id == id
                          && data->pairs[i + 2][j].id == id)
            {
                list[i][j]++;
                list[i + 1][j] += 2;
                list[i + 2][j]++;
                ret = 1;
            }

            if (j + 2 < data->dim.j && data->pairs[i][j + 1].id == id
                          && data->pairs[i][j + 2].id == id)
            {
                list[i][j]++;
                list[i][j + 1] += 2;
                list[i][j + 2]++;
                ret = 1;
            }
        }

    return ret;
}

/* Fill an array with the list of pieces that can be moved. A value of 1
 * indicates the piece can be moved right. A value of 2 means it can be
 * moved up, and a value of 3 means both moves are possible. The number
 * of possible moves is returned. */
int Board::ListMoves(int moves[MAX_WIDTH][MAX_HEIGHT])
{
    int ret = 0;

    for (int j = 0; j < data->dim.j; j++)
        for (int i = 0; i < data->dim.i; i++)
            moves[i][j] = 0;

    for (int j = 0; j < data->dim.j; j++)
        for (int i = 0; i < data->dim.i; i++)
        {
            /* Copy neighbourhood to a local buffer */
            int tmp[6][6];

            for (int dj = -2; dj <= 3; dj++)
                for (int di = -2; di <= 3; di++)
                    if (j + dj >= 0 && j + dj < data->dim.j
                         && i + di >= 0 && i + di < data->dim.i)
                        tmp[2 + di][2 + dj] = data->pairs[i + di][j + dj].id;
                    else
                        tmp[2 + di][2 + dj] = 0;

            /* +--+--+--+--+--+--+
             * |  |  |25|  |  |  |
             * +--+--+--+--+--+--+
             * |  |  |24|34|  |  |
             * +--+--+--+--+--+--+
             * |03|13|c |33|43|  |
             * +--+--+--+--+--+--+
             * |02|12|a |b |42|52|
             * +--+--+--+--+--+--+
             * |  |11|21|31|  |  |
             * +--+--+--+--+--+--+
             * |  |  |20|30|  |  |
             * +--+--+--+--+--+--+ */
            int a = tmp[2][2];
            int b = tmp[3][2] ? tmp[3][2] : -1;
            int c = tmp[2][3] ? tmp[2][3] : -1;

            /* Try moving right */
            if ((a == tmp[3][0] && a == tmp[3][1]) ||
                (a == tmp[3][1] && a == tmp[3][3]) ||
                (a == tmp[3][3] && a == tmp[3][4]) ||
                (a == tmp[4][2] && a == tmp[5][2]) ||
                (b == tmp[2][0] && b == tmp[2][1]) ||
                (b == tmp[2][1] && b == tmp[2][3]) ||
                (b == tmp[2][3] && b == tmp[2][4]) ||
                (b == tmp[0][2] && b == tmp[1][2]))
            {
                moves[i][j] |= 1;
                ret++;
            }

            /* Try moving up */
            if ((a == tmp[0][3] && a == tmp[1][3]) ||
                (a == tmp[1][3] && a == tmp[3][3]) ||
                (a == tmp[3][3] && a == tmp[4][3]) ||
                (a == tmp[2][4] && a == tmp[2][5]) ||
                (c == tmp[0][2] && c == tmp[1][2]) ||
                (c == tmp[1][2] && c == tmp[3][2]) ||
                (c == tmp[3][2] && c == tmp[4][2]) ||
                (c == tmp[2][0] && c == tmp[2][1]))
            {
                moves[i][j] |= 2;
                ret++;
            }
        }

    return ret;
}

int Board::GetRandomId() const
{
    int max = data->npieces;

    if (max > data->minnpieces)
        max--;

    return 1 + rand() % max;
}

void Board::Resolve()
{
    int list[MAX_PIECES][MAX_PIECES];
    int count[MAX_PIECES * MAX_PIECES];

    for (int j = 0; j < data->dim.j; j++)
        for (int i = 0; i < data->dim.i; i++)
            list[i][j] = -1;
    memset(count, 0, sizeof(count));

    int seq = 0, effect = 0;

    /* Count connected tiles */
    for (int j = 0; j < data->dim.j; j++) for (int i = 0; i < data->dim.i; i++)
    {
        if (!data->pairs[i][j].id)
            continue;

        if (data->pairs[i][j].id >= data->maxnpieces)
            continue;

        if (list[i][j] != -1)
            continue;

        list[i][j] = seq;
        count[seq] = TagNeighbours(list, i, j);
        if (count[seq] >= 3)
            effect = 1;
        seq++;
    }

    /* Only continue if there is an effect */
    if (!effect)
        return;

    /* Add tiles to a mash; add mash to our list */
    Mash *mash = new Mash(data->emitter);
    Ticker::Ref(mash);

    for (int j = 0; j < data->dim.j; j++) for (int i = 0; i < data->dim.i; i++)
    {
        if (list[i][j] == -1)
            continue;
        if (count[list[i][j]] < 3)
            continue;

        mash->AddPiece(data->pairs[i][j].piece);
        data->pairs[i][j].piece = NULL;
    }

    mash->nextmash = data->mashes;
    data->mashes = mash;

    /* Create new pieces where necessary */
    for (int j = 0; j < data->dim.j; j++) for (int i = 0; i < data->dim.i; i++)
    {
        if (list[i][j] == -1)
            continue;
        if (count[list[i][j]] < 3)
        {
            if (!data->pairs[i][j].piece)
                data->pairs[i][j].id = 0;
            continue;
        }

        data->pairs[i][j].id++;
        if (data->pairs[i][j].id > data->npieces
                && data->pairs[i][j].id <= data->maxnpieces)
        {
            data->npieces++;
            data->thumbs->SetMax(data->npieces);
        }
        data->pairs[i][j].piece = new Piece(Piece::PIECE_FUSION,
                                            data->emitter, vec2i(i, j),
                                            data->pairs[i][j].id);
        Ticker::Ref(data->pairs[i][j].piece);
        data->pairs[i][j].piece->SetPos(vec2i(i, j) * data->size);
        data->thumbs->AddCount(data->pairs[i][j].id, 1);
        count[list[i][j]] = 0;
        list[i][j] = -1;
    }

    /* Move everything down */
    for (int j = data->dim.j; j--;) for (int i = 0; i < data->dim.i; i++)
    {
        if (list[i][j] == -1 || data->pairs[i][j].piece)
            continue;

        for (int j2 = j + 1; j2 < data->dim.j; j2++)
        {
            data->pairs[i][j2 - 1] = data->pairs[i][j2];
            if (data->pairs[i][j2 - 1].id)
            {
                data->pairs[i][j2 - 1].piece->SetCell(vec2i(i, j2 - 1));
                data->pairs[i][j2 - 1].piece->Move(vec2i(i, j2 - 1) * data->size);
            }
            list[i][j2 - 1] = list[i][j2];
        }

        data->pairs[i][data->dim.j - 1].id = 0;
        list[i][data->dim.j - 1] = -1;
    }

    /* Start again (FIXME: make this a while() loop) */
    Resolve();
}

int Board::TagNeighbours(int list[MAX_PIECES][MAX_PIECES], int i, int j)
{
    vec2i const off[] = { vec2i(-1, 0), vec2i(1, 0), vec2i(0, -1), vec2i(0, 1) };

    int count = 1;

    for (int n = 0; n < 4; n++)
    {
        int i2 = i + off[n].i;
        int j2 = j + off[n].j;

        if (i2 >= 0 && i2 < data->dim.i && j2 >= 0 && j2 < data->dim.j
             && data->pairs[i2][j2].id == data->pairs[i][j].id
             && list[i2][j2] == -1)
        {
            list[i2][j2] = list[i][j];
            count += TagNeighbours(list, i2, j2);
        }
    }
    return count;
}

Board::~Board()
{
    Input::UntrackMouse(this);

    switch (data->game)
    {
    case GAME_HUNT:
        for (int j = 0; j < data->dim.j; j++)
            for (int i = 0; i < data->dim.i; i++)
            {
                data->pairs[i][j].piece->SetBelow(NULL);
                Ticker::Unref(data->pairs[i][j].piece);
            }
        break;
    case GAME_FUSION:
        for (int j = 0; j < data->dim.j; j++)
            for (int i = 0; i < data->dim.i; i++)
                if (data->pairs[i][j].id)
                    Ticker::Unref(data->pairs[i][j].piece);
        Ticker::Unref(data->current[0].piece);
        Ticker::Unref(data->current[1].piece);
        break;
    }
    Ticker::Unref(data->thumbs);
    Ticker::Unref(data->score);
    while (data->mashes)
    {
        Ticker::Unref(data->mashes);
        data->mashes = data->mashes->nextmash;
    }
    /* FIXME: the emitter may be destroyed after the Tiler is removed,
     * because the last Tiler tick may be done just after the emitter
     * scheduled its sprites! */
    Ticker::Unref(data->emitter);
    Tiler::Deregister(data->screen);
    Tiler::Deregister(data->board);
    Tiler::Deregister(data->tiles);
    Tiler::Deregister(data->icons);
    Sampler::Deregister(data->click);
    Sampler::Deregister(data->whip);
    delete data;
}