source: trunk/monsterz/piece.cpp @ 958 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 "core.h"

using namespace std;
using namespace lol;

#include "piece.h"
#include "monsterz.h"

/*
 * Piece implementation class
 */

class PieceData
{
    friend class Piece;

private:
    Piece::piece_t piece;

    TileSet *tileset;
    Emitter *emitter;
    Piece *above, *below;
    ivec2 size, cell, pos, pos_src, pos_dst, off, off_src;
    int pieceid;
    float speed, timer;

    struct
    {
        /* The idle loop */
        float idle, idle_max;
        /* Piece is blinking */
        float blink;
        /* Piece is popping */
        float pop;
    }
    timers;

    enum
    {
        /* Piece is idle, at its normal position */
        IDLE,
        /* Piece is being grabbed */
        GRAB,
        /* Piece was released after a grab */
        UNGRAB,
        MOVE,
        POP,
        DEAD,
    }
    state;

    char namebuf[40];
};

/*
 * Public Piece class
 */

Piece::Piece(piece_t piece, Emitter *emitter, ivec2 cell, int pieceid)
  : data(new PieceData())
{
    data->piece = piece;

    data->emitter = emitter;
    Ticker::Ref(emitter);
    data->above = NULL;
    data->below = NULL;
    data->cell = cell;
    data->state = PieceData::IDLE;
    data->timers.idle = 0.0f;
    data->timers.idle_max = RandF(DELAY_IDLE);
    data->timers.blink = RandF(2 * DELAY_BLINK);
    data->timers.pop = 0.0f;

    switch (data->piece)
    {
    case PIECE_HUNT:
        data->size = 48;
        data->tileset = Tiler::Register(PNG_TILES, data->size, 0, 1.0f);
        data->pieceid = 80 + 20 * pieceid;
        break;
    }

    data->pos = data->cell * data->size;
    data->off = 0;
}

char const *Piece::GetName()
{
    sprintf(data->namebuf, "<piece> %ix%i @ %i,%i",
            data->size.x, data->size.y, data->cell.x, data->cell.y);
    return data->namebuf;
}

void Piece::SetCell(ivec2 cell) { data->cell = cell; }
ivec2 Piece::GetCell() const { return data->cell; }

void Piece::SetPos(ivec2 pos) { data->pos = pos; }
ivec2 Piece::GetPos() const { return data->pos; }

ivec2 Piece::GetOffset() const { return data->off; }
ivec2 Piece::GetSize() const { return data->size; }

ivec2 Piece::GetShift() const
{
    return data->pos + data->off - data->cell * data->size;
}

void Piece::SetAbove(Piece *above)
{
    Piece *old = data->above;

    if (above == old)
        return;

    if (old)
        Ticker::Unref(old);
    data->above = above;
    if (above)
        Ticker::Ref(above);

    if (old)
        old->SetBelow(NULL);
    if (above)
        above->SetBelow(this);
}

Piece *Piece::GetAbove() const
{
    return data->above;
}

void Piece::SetBelow(Piece *below)
{
    Piece *old = data->below;

    if (below == old)
        return;

    if (old)
        Ticker::Unref(old);
    data->below = below;
    if (below)
        Ticker::Ref(below);

    if (old)
        old->SetAbove(NULL);
    if (below)
        below->SetAbove(this);
}

Piece *Piece::GetBelow() const
{
    return data->below;
}

int Piece::IsDead() const
{
    return data->state == PieceData::DEAD;
}

int Piece::Pop()
{
    switch (data->state)
    {
    case PieceData::IDLE:
    case PieceData::GRAB:
    case PieceData::UNGRAB:
    case PieceData::MOVE:
    case PieceData::POP:
        data->state = PieceData::POP;
        data->timers.pop = DELAY_DUH + DELAY_POP;
        return 1;
    default:
        return 0;
    }
}

int Piece::Grab(ivec2 dir)
{
    switch (data->state)
    {
    case PieceData::UNGRAB:
    case PieceData::MOVE:
        /* Only allow swaps when piece is close enough to its target cell. */
        if (GetShift().sqlen() > data->size.sqlen() / 8)
            return 0;
        /* Fall through */
    case PieceData::IDLE:
    case PieceData::GRAB:
        data->state = PieceData::GRAB;
        data->off += dir;
        return 1;
    default:
        return 0;
    }
}

int Piece::Ungrab(ivec2 pos)
{
    switch (data->state)
    {
    case PieceData::IDLE:
    case PieceData::GRAB:
    case PieceData::UNGRAB:
    case PieceData::MOVE:
        data->state = PieceData::UNGRAB;
        data->speed = 0.4f;
        data->timer = 0.0f;
        data->off = data->off_src = data->off + data->pos - pos;
        data->pos = data->pos_src = data->pos_dst = pos;
        return 1;
    default:
        return 0;
    }
}

int Piece::Move(ivec2 pos)
{
    switch (data->state)
    {
    case PieceData::IDLE:
    case PieceData::UNGRAB:
    case PieceData::MOVE:
        data->state = PieceData::MOVE;
        data->speed = 0.3f;
        data->timer = 0.0f;
        data->pos_src = data->pos;
        data->pos_dst = pos;
        data->off_src = data->off;
        return 1;
    case PieceData::GRAB:
    default:
        return 0;
    }
}

void Piece::TickGame(float deltams)
{
    data->timers.blink -= deltams;
    if (data->timers.blink < 0.0f)
        data->timers.blink = RandF(DELAY_BLINK, 2 * DELAY_BLINK);

    data->timers.idle -= deltams;
    if (data->timers.idle < 0.0f)
        data->timers.idle = data->timers.idle_max
                          = RandF(DELAY_IDLE, 2 * DELAY_IDLE);

    data->timers.pop -= deltams;

    switch (data->state)
    {
    case PieceData::IDLE:
    case PieceData::GRAB:
        break;
    case PieceData::UNGRAB:
    case PieceData::MOVE:
    {
        data->timer += deltams;

        ivec2 trip = data->pos_dst - data->pos_src;
        float pos_time = trip.len() / data->speed;
        float t = pos_time ? data->timer / pos_time : 1.0f;
        if (t >= 1.0f)
            t = 1.0f;
        data->pos = data->pos_src + (t * trip + 0.5f);

        float off_time = data->off_src.len() / data->speed;
        t = off_time ? data->timer / off_time : 1.0f;
        if (t >= 1.0f)
            t = 1.0f;
        data->off = (1.0f - t) * data->off_src;

        /* If the piece below is blocking us, clamp our position and
         * start falling again. */
        if (data->state == PieceData::MOVE && data->below
             && data->pos.y < data->below->data->pos.y + data->size.y)
        {
            data->pos.y = data->below->data->pos.y + data->size.y;
            data->pos_src = data->pos;
            data->off_src = data->off;
            data->timer = 0.0f;
        }
        if (data->timer > pos_time + 200.0f && data->timer > off_time + 200.0f)
            data->state = PieceData::IDLE;
        break;
    }
    case PieceData::POP:
        /* If piece has finished its pop animation, spawn particles and
         * kill the piece. */
        if (data->timers.pop < 0.0f)
        {
            vec3 pos(data->pos.x + 24, data->pos.y + 72, 5);
            int start = data->pieceid + 12;
            int stop = data->pieceid + 15;
            for (int pieceid = start; pieceid < stop; pieceid++)
            {
                float angle = RandF(-1.2f, 1.2f);
                float speed = RandF(0.3f, 0.5f);
                vec3 vel(speed * sinf(angle), speed * cosf(angle), 0.0f);
                data->emitter->AddParticle(pieceid, pos, vel);
            }

            data->state = PieceData::DEAD;
        }
        break;
    case PieceData::DEAD:
        /* If piece is dead, there's nothing we can do. */
        break;
    }
    Entity::TickGame(deltams);
}

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

    int pieceid = data->pieceid, off = 0;
    int x = data->pos.x + data->off.x + 24;
    int y = data->pos.y + data->off.y + 72;
    int z = 2;

    /* Optional modifiers */
    switch (data->state)
    {
    case PieceData::IDLE:
    {
        off = data->timers.idle * 3 / data->timers.idle_max;
        if (off < 0) off = 0;
        if (off > 2) off = 2;
        if (data->timers.blink < DURATION_BLINK) off = 3;
        break;
    }
    case PieceData::GRAB:
        off = 3;
        z = 10;
        break;
    case PieceData::UNGRAB:
        if ((data->cell * data->size - data->pos_src).sqlen()
              > data->size.sqlen() / 8)
            off = 7;
        z = 8;
        break;
    case PieceData::MOVE:
        z = 3;
        break;
    case PieceData::POP:
    {
        off = 4 - (int)(data->timers.pop * 5 / DELAY_POP);
        if (off < 0) off = 0;
        if (off > 4) off = 4;
        off += 7;
        break;
    }
    case PieceData::DEAD:
        break;
    }

    /* Only change image if the required frame is available */
    switch (data->piece)
    {
    case PIECE_HUNT:
        pieceid += off;
        break;
    }

    if (data->state != PieceData::DEAD)
        Scene::GetDefault()->AddTile(data->tileset, pieceid, ivec3(x, y, z), 0);

    if (data->state == PieceData::GRAB && Platform::GetMouseCount())
        Scene::GetDefault()->AddTile(data->tileset, 0, ivec3(x, y, 9), 0);
}

Piece::~Piece()
{
    if (data->above)
        Ticker::Unref(data->above);
    if (data->below)
        Ticker::Unref(data->below);
    Ticker::Unref(data->emitter);
    Tiler::Deregister(data->tileset);
    delete data;
}