source: trunk/monsterz/piece.cpp @ 311 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"
#include "piece.h"
#include "monsterz.h"

/*
 * Piece implementation class
 */

class PieceData
{
    friend class Piece;

private:
    Emitter *emitter;
    Piece *above, *below;
    int tiler;
    int2 cell, pos, src, dst;
    int id;
    float speed, timer;

    enum
    {
        IDLE,
        BLINK,
        GRAB,
        UNGRAB,
        MOVE,
        POP,
        DEAD,
    }
    state;
};

/*
 * Public Piece class
 */

Piece::Piece(Emitter *emitter, int2 cell, int id)
  : data(new PieceData())
{
    data->emitter = emitter;
    Ticker::Ref(emitter);
    data->above = NULL;
    data->below = NULL;
    data->tiler = Tiler::Register(PNG_TILES, 48, 48, 1.0f);
    data->cell = cell;
    data->pos = cell * 48;
    data->id = id;
    data->state = PieceData::IDLE;
    data->timer = RandF(DELAY_IDLE);
}

void Piece::SetCell(int2 cell)
{
    data->cell = cell;
}

int2 Piece::GetCell() const
{
    return data->cell;
}

void Piece::SetPos(int2 pos)
{
    data->pos = pos;
}

int2 Piece::GetPos() const
{
    return data->pos;
}

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::Blink()
{
    switch (data->state)
    {
    case PieceData::IDLE:
        data->state = PieceData::BLINK;
        data->timer = DELAY_BLINK;
        return 1;
    default:
        return 0;
    }
}

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

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

int Piece::Ungrab(int2 pos)
{
    switch (data->state)
    {
    case PieceData::IDLE:
    case PieceData::BLINK:
    case PieceData::GRAB:
    case PieceData::UNGRAB:
    case PieceData::MOVE:
        data->state = PieceData::UNGRAB;
        data->speed = 0.4f;
        data->timer = 0.0f;
        data->src = data->pos;
        data->dst = pos;
        return 1;
    default:
        return 0;
    }
}

int Piece::Move(int2 pos)
{
    switch (data->state)
    {
    case PieceData::IDLE:
    case PieceData::BLINK:
    case PieceData::UNGRAB:
    case PieceData::MOVE:
        data->state = PieceData::MOVE;
        data->speed = 0.3f;
        data->timer = 0.0f;
        data->src = data->pos;
        data->dst = pos;
        return 1;
    case PieceData::GRAB:
    default:
        return 0;
    }
}

void Piece::TickGame(float deltams)
{
    switch (data->state)
    {
    case PieceData::IDLE:
        data->timer -= deltams;
        if (data->timer < 0.0f)
            data->timer = DELAY_IDLE;
        break;
    case PieceData::BLINK:
        data->timer -= deltams;
        if (data->timer < 0.0f)
        {
            data->state = PieceData::IDLE;
            data->timer = RandF(DELAY_IDLE);
        }
        break;
    case PieceData::GRAB:
        break;
    case PieceData::UNGRAB:
    case PieceData::MOVE:
    {
        data->timer += deltams;
        int2 trip = data->dst - data->src;
        float moving_time = trip.len() / data->speed;
        float t = moving_time ? data->timer / moving_time : 1.0f;
        if (t >= 1.0f)
            t = 1.0f;
        data->pos = data->src + (t * trip + 0.5f);
        /* 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 + 48)
        {
            data->pos.y = data->below->data->pos.y + 48;
            data->src = data->pos;
            data->timer = 0.0f;
        }
        if (data->timer > moving_time + 200.0f)
        {
            data->state = PieceData::IDLE;
            data->timer = RandF(DELAY_IDLE);
        }
        break;
    }
    case PieceData::POP:
        data->timer -= deltams;
        if (data->timer < 0.0f)
        {
            float3 pos(data->pos.x + 24, data->pos.y + 177, 5);
            int start = data->id + 12;
            int stop = data->id + 15;
            for (int id = start; id < stop; id++)
            {
                float angle = RandF(-1.2f, 1.2f);
                float speed = RandF(0.3f, 0.5f);
                float3 vel(speed * sinf(angle), speed * cosf(angle), 0.0f);
                data->emitter->AddParticle(id, pos, vel);
            }

            data->state = PieceData::DEAD;
        }
        break;
    case PieceData::DEAD:
        break;
    }
    Entity::TickGame(deltams);
}

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

    int id = data->id;
    int x = data->pos.x + 24;
    int y = data->pos.y + 177;
    int z = 2;

    /* Optional modifiers */
    switch (data->state)
    {
    case PieceData::IDLE:
    {
        int off = data->timer * 3 / DELAY_IDLE;
        if (off < 0) off = 0;
        if (off > 2) off = 2;
        id = data->id + off;
        break;
    }
    case PieceData::BLINK:
        id = data->id + 3;
        break;
    case PieceData::GRAB:
        id = data->id + 3;
        z = 4;
        break;
    case PieceData::UNGRAB:
        if ((data->cell * 48 - data->src).sqlen() > 24 * 24)
            id = data->id + 7;
        z = 4;
        break;
    case PieceData::MOVE:
        z = 3;
        break;
    case PieceData::POP:
    {
        int off = 4 - (data->timer * 5 / DELAY_POP);
        if (off < 0) off = 0;
        if (off > 4) off = 4;
        id = data->id + 7 + off;
        break;
    }
    case PieceData::DEAD:
        break;
    }

    if (data->state != PieceData::DEAD)
        Scene::GetDefault()->AddTile((data->tiler << 16) | id, x, y, z, 0);

    if (data->state == PieceData::GRAB)
        Scene::GetDefault()->AddTile((data->tiler << 16) | 0, x, y, 5, 0);
}

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