source: trunk/monsterz/mash.cpp @ 746 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 <cstdlib>
#include <cmath>

#include "core.h"

using namespace lol;

#include "mash.h"
#include "monsterz.h"

/*
 * Mash implementation class
 */

class MashData
{
    friend class Mash;

private:
    Emitter *emitter;
    int duh, pop;
    Piece *pieces[MAX_WIDTH * MAX_HEIGHT];
    vec2i cells[MAX_WIDTH * MAX_HEIGHT];
    int npieces;
    float timer;

    enum
    {
        WAIT,
        DUH,
        POP,
        DEAD,
    }
    state;
};

/*
 * Public Mash class
 */

Mash::Mash(Emitter *emitter)
  : data(new MashData()),
    nextmash(NULL)
{
    data->emitter = emitter;
    Ticker::Ref(emitter);
    data->duh = Sampler::Register(WAV_DUH);
    data->pop = Sampler::Register(WAV_POP);
    data->npieces = 0;
    data->state = MashData::WAIT;
}

void Mash::AddPiece(Piece *piece)
{
    data->pieces[data->npieces] = piece;
    data->cells[data->npieces] = piece->GetCell();
    data->npieces++;
}

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

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

    switch (data->state)
    {
    case MashData::WAIT:
    {
        int allready = 1;
        for (int n = 0; n < data->npieces && allready; n++)
        {
            /* If piece is still too far, don't start the animation */
            vec2i shift = data->pieces[n]->GetShift();
            if (abs(shift.y) + abs(shift.x) > 0)
                allready = 0;
        }

        if (allready)
        {
            Sampler::PlaySample(data->duh);
            for (int n = 0; n < data->npieces; n++)
                data->pieces[n]->Pop();
            data->timer = DELAY_DUH;
            data->state = MashData::DUH;
        }
        break;
    }
    case MashData::DUH:
        if ((data->timer -= deltams) < 0.0f)
        {
            Sampler::PlaySample(data->pop);
            data->state = MashData::POP;
        }
        break;
    case MashData::POP:
    {
        int alldead = 1;
        for (int n = 0; n < data->npieces && alldead; n++)
            if (!data->pieces[n]->IsDead())
                alldead = 0;
        if (alldead)
        {
            for (int n = 0; n < data->npieces; n++)
            {
                /* Remove links for this piece */
                Piece *above = data->pieces[n]->GetAbove();
                Piece *below = data->pieces[n]->GetBelow();
                data->pieces[n]->SetAbove(NULL);
                data->pieces[n]->SetBelow(NULL);
                /* If there is a new link to create, create it */
                if (above && below)
                    above->SetBelow(below);
                /* Give away references to this piece */
                Ticker::Unref(data->pieces[n]);
            }
            data->npieces = 0;
            data->state = MashData::DEAD;
        }
        break;
    }
    case MashData::DEAD:
        break;
    }
}

void Mash::TickDraw(float deltams)
{
    Entity::TickDraw(deltams);
}

Mash::~Mash()
{
    for (int n = 0; n < data->npieces; n++)
    {
        data->pieces[n]->SetBelow(NULL);
        Ticker::Unref(data->pieces[n]);
    }
    Sampler::Deregister(data->duh);
    Sampler::Deregister(data->pop);
    Ticker::Unref(data->emitter);
    delete data;
}