source: trunk/monsterz/board.cpp @ 297 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 <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

#include "core.h"
#include "board.h"
#include "piece.h"
#include "mash.h"
#include "monsterz.h"

/*
 * Board implementation class
 */

class BoardData
{
    friend class Board;

private:
    Game *game;
    int screen, board, tiles;
    int click, whip;
    Piece *pieces[8][8];
    Piece *grabbed;
    Mash *mashes;
    Emitter *emitter;
    int2 src_cell, dst_cell;

    int2 mouse;
    int3 buttons;
    float nextblink, whipdelay;

    enum
    {
        IDLE,
        BADCLICK,
        GRAB,
    }
    state;
};

/*
 * Public Board class
 */

Board::Board(Game *game)
  : data(new BoardData())
{
    data->game = game;
    Ticker::Ref(game);
    data->screen = Tiler::Register(PNG_BACKGROUND, 640, 480, 1.0f);
    data->board = Tiler::Register(PNG_BOARD, 384, 384, 1.0f);
    data->tiles = Tiler::Register(PNG_TILES, 48, 48, 1.0f);
    data->click = Sampler::Register(WAV_CLICK);
    data->whip = Sampler::Register(WAV_WHIP);

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

    srand(rand() ^ time(NULL));

restart:
    for (int j = 0; j < 8; j++)
        for (int i = 0; i < 8; i++)
        {
            int id = 100 + 20 * (rand() % 7);
            data->pieces[i][j] = new Piece(data->emitter, int2(i, j), id);
            if (j)
                data->pieces[i][j]->SetBelow(data->pieces[i][j - 1]);
            Ticker::Ref(data->pieces[i][j]);
        }

    int list[8][8];
    if (ListMashes(list))
    {
        for (int j = 0; j < 8; j++)
            for (int i = 0; i < 8; i++)
            {
                data->pieces[i][j]->SetBelow(NULL);
                Ticker::Unref(data->pieces[i][j]);
            }
        goto restart;
    }

    data->mashes = NULL;
    data->nextblink = 0.0f;
    data->whipdelay = 0.0f;
    data->state = BoardData::IDLE;
}

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

    int2 mouse = Input::GetMousePos();
    int3 buttons = Input::GetMouseButtons();

    /* If possible, make a random monster blink */
    if ((data->nextblink -= deltams) < 0.0f)
    {
        data->pieces[rand() % 8][rand() % 8]->Blink();
        data->nextblink = (float)(200 + rand() % 500);
    }

    /* 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::IDLE:
        /* Should we start dragging something? */
        if (buttons[0] && !data->buttons[0])
        {
            int x = mouse.x - 24;
            int y = mouse.y - 72;
            if (x >= 0 && x < 8 * 48 && y >= 0 && y < 8 * 48)
            {
                if (data->pieces[x / 48][y / 48]->Grab(int2(0, 0)))
                {
                    Sampler::PlaySample(data->click);
                    data->grabbed = data->pieces[x / 48][y / 48];
                    data->src_cell = int2(x / 48, y / 48);
                    data->dst_cell = int2(-1);
                    data->state = BoardData::GRAB;
                }
                else
                    data->state = BoardData::BADCLICK;
            }
            else
                data->state = BoardData::BADCLICK;
        }
        break;
    case BoardData::GRAB:
        if (mouse.x >= 0 && mouse.y >= 0)
        {
            /* Mouse is still in the window, keep grabbing */
            data->grabbed->Grab(mouse - data->mouse);
            int2 cur_pos = data->grabbed->GetPos();
            int2 cur_cell = (cur_pos + 24) / 48;
            if (cur_cell.i < 0 || cur_cell.i >= 8
                 || cur_cell.j < 0 || cur_cell.j >= 8
                 || (cur_pos - cur_cell * 48).sqlen() > 24 * 24
                 || (cur_cell - data->src_cell).sqlen() != 1)
                cur_cell = int2(-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 != int2(-1))
                    data->pieces[data->dst_cell.i]
                                [data->dst_cell.j]->Ungrab(data->dst_cell * 48);
                if (cur_cell != int2(-1))
                    data->pieces[cur_cell.i]
                                [cur_cell.j]->Ungrab(data->src_cell * 48);
                data->dst_cell = cur_cell;
            }
        }
        if (!buttons[0] || mouse.x < 0 || mouse.y < 0
             || (data->src_cell * 48
                  - data->grabbed->GetPos()).sqlen() > 100 * 100)
        {
            /* Mouse released, or exited window, or dragged too far. */
            data->grabbed->Ungrab(data->grabbed->GetCell() * 48);
            if (data->dst_cell != int2(-1))
                Switch(data->src_cell, data->dst_cell);
            data->state = BoardData::IDLE;
        }
        break;
    case BoardData::BADCLICK:
        if (!buttons[0])
            data->state = BoardData::IDLE;
        break;
    }

    data->mouse = mouse;
    data->buttons = buttons;
}

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

    Scene::GetDefault()->AddTile((data->screen << 16) | 0, 0, 1050, 0, 0);
    Scene::GetDefault()->AddTile((data->board << 16) | 0, 24, 912, 1, 0);

    if (data->mouse.x >= 0 && data->mouse.y >= 0)
    {
        int x = data->mouse.x - 2;
        int y = data->mouse.y + 59;
        Scene::GetDefault()->AddTile((data->tiles << 16) | 22, x, y, 10, 0);
    }
}

void Board::Switch(int2 cell_a, int2 cell_b)
{
    Piece *a = data->pieces[cell_a.i][cell_a.j];
    Piece *b = data->pieces[cell_b.i][cell_b.j];
    data->pieces[cell_a.i][cell_a.j] = b;
    data->pieces[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[8][8];

    if (!ListMashes(list))
    {
        data->pieces[cell_a.i][cell_a.j] = a;
        data->pieces[cell_b.i][cell_b.j] = b;
        a->Ungrab(cell_a * 48);
        b->Ungrab(cell_b * 48);
        return;
    }

    /* Perform the swap */
    a->SetCell(cell_b);
    a->Ungrab(cell_b * 48);
    b->SetCell(cell_a);
    b->Ungrab(cell_a * 48);

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

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

        for (int j = 8; j--;) for (int i = 0; i < 8; i++)
        {
            if (!list[i][j])
                continue;

            /* The mash becomes the new owner of the disappearing piece */
            mash->AddPiece(data->pieces[i][j]);

            Piece *below = data->pieces[i][7];

            /* Change coordinates for the whole column above */
            for (int j2 = j + 1; j2 < 8; j2++)
            {
                data->pieces[i][j2 - 1] = data->pieces[i][j2];
                data->pieces[i][j2 - 1]->SetCell(int2(i, j2 - 1));
                data->pieces[i][j2 - 1]->Move(int2(i, j2 - 1) * 48);
                list[i][j2 - 1] = list[i][j2];
            }

            /* Spawn a new piece above all the others and attach it to
             * the board. */
            int2 newpos = int2(i * 48, below->GetPos().y + 48);
            int id = 100 + 20 * (rand() % 7);
            data->pieces[i][7] = new Piece(data->emitter, int2(i, 7), id);
            data->pieces[i][7]->SetBelow(below);
            data->pieces[i][7]->SetPos(newpos);
            data->pieces[i][7]->Move(int2(i, 7) * 48);
            Ticker::Ref(data->pieces[i][7]);
            list[i][7] = 0;
        }

        mash->nextmash = data->mashes;
        data->mashes = mash;
    }
    while(ListMashes(list));
}

int Board::ListMashes(int list[8][8])
{
    int ret = 0;

    for (int j = 0; j < 8; j++)
        for (int i = 0; i < 8; i++)
            list[i][j] = 0;

    for (int j = 0; j < 8; j++)
        for (int i = 0; i < 8; i++)
        {
            int id = data->pieces[i][j]->GetId();

            if (i + 2 < 8 && data->pieces[i + 1][j]->GetId() == id
                          && data->pieces[i + 2][j]->GetId() == id)
            {
                list[i][j] = list[i + 1][j] = list[i + 2][j] = 1;
                ret = 1;
            }

            if (j + 2 < 8 && data->pieces[i][j + 1]->GetId() == id
                          && data->pieces[i][j + 2]->GetId() == id)
            {
                list[i][j] = list[i][j + 1] = list[i][j + 2] = 1;
                ret = 1;
            }
        }

    return ret;
}

Board::~Board()
{
    Ticker::Unref(data->game);
    for (int j = 0; j < 8; j++)
        for (int i = 0; i < 8; i++)
        {
            data->pieces[i][j]->SetBelow(NULL);
            Ticker::Unref(data->pieces[i][j]);
        }
    while (data->mashes)
    {
        Ticker::Unref(data->mashes);
        data->mashes = data->mashes->nextmash;
    }
    Ticker::Unref(data->emitter);
    Tiler::Deregister(data->board);
    Tiler::Deregister(data->screen);
    Tiler::Deregister(data->tiles);
    Sampler::Deregister(data->click);
    Sampler::Deregister(data->whip);
    delete data;
}