source: trunk/monsterz/title.cpp @ 1046 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

#ifdef WIN32
#   define _USE_MATH_DEFINES /* for M_PI */
#   define WIN32_LEAN_AND_MEAN
#   include <windows.h>
#endif

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

#include "core.h"

using namespace std;
using namespace lol;

#include "monsterz.h"
#include "title.h"

/*
 * Title implementation class
 */

class TitleData
{
    friend class Title;

private:
    TileSet *title, *stars, *clouds, *logo, *ground, *rocks;
    TileSet *anim[6];
    TileSet *event[7];

    Sprite *logo_sprite;

    enum
    {
        IDLE,
        ANIM,
        EVENT,
    }
    state;

    enum
    {
        DAY,
        NIGHT,
        STEALTH,
        RADIO,
    }
    period, nextperiod;

    vec2 cloudpos[MAX_CLOUDS];
    vec2 cloudspeed[MAX_CLOUDS];

    ivec2 ground_pos, rocks_pos;

    struct
    {
        TileSet *tiles;
        int y;
        float duration, timer;
    }
    eagle;

    float timer, length;
    int nframes, animid;

    /* Sky shader test */
    Gradient *gradient;
};

static ivec2 const animsize[] =
{
    ivec2(384, 384),
    ivec2(284, 81),
    ivec2(38, 146),
    ivec2(29, 137),
    ivec2(284, 82),
    ivec2(384, 384),
};

static ivec2 const animpos[] =
{
    ivec2(0, 0),
    ivec2(65, 255),
    ivec2(239, 168),
    ivec2(248, 168),
    ivec2(63, 255),
    ivec2(0, 0),
};

static ivec2 const eventsize[] =
{
    ivec2(143, 16),
    ivec2(68, 49),
    ivec2(17, 29),
    ivec2(50, 80),
    ivec2(237, 238),
    ivec2(59, 53),
    ivec2(140, 15),
};

static ivec2 const eventpos[] =
{
    ivec2(0, 322),
    ivec2(316, 286),
    ivec2(246, 245),
    ivec2(279, 173),
    ivec2(42, 101),
    ivec2(231, 154),
    ivec2(0, 322),
};

/*
 * Public Title class
 */

Title::Title()
  : data(new TitleData())
{
    /* FIXME: this should not be hardcoded */
    position = ivec3(0, 0, 1);
    bbox[0] = position;
    bbox[1] = bbox[0] + ivec3(640, 480, 0);

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

    data->logo = Tiler::Register(PNG_TITLE_LOGO, ivec2(380, 181), ivec2(0), 1.0f);
    data->logo_sprite = new Sprite(data->logo, 0);
    data->logo_sprite->position = vec3(640 / 2 - 380 / 2, 250, 10);
    Ticker::Ref(data->logo_sprite);

    data->ground = Tiler::Register(PNG_TITLE_GROUND, ivec2(384, 80), ivec2(0), 1.0f);
    data->ground_pos = ivec2((bbox[1] - bbox[0]).xy() / ivec2(2, 4))
                     - ivec2(192, 80);

    data->rocks = Tiler::Register(PNG_TITLE_ROCKS, ivec2(640, 155), ivec2(0), 1.0f);
    data->rocks_pos = ivec2((bbox[1] - bbox[0]).xy() / ivec2(2, 2))
                    - ivec2(320, 240);

    data->title = Tiler::Register(PNG_TITLE, ivec2(384), ivec2(0), 1.0f);
    data->stars = Tiler::Register(PNG_STARS, ivec2(384, 144), ivec2(0), 1.0f);
    data->clouds = Tiler::Register(PNG_CLOUDS, ivec2(160, 32), ivec2(0), 1.0f);
    data->eagle.tiles = Tiler::Register(PNG_EAGLE, ivec2(16), ivec2(0), 1.0f);
    for (int n = 0; n < 6; n++)
        data->anim[n] = Tiler::Register(PNG_TITLEANIM[n],
                                        animsize[n], ivec2(0), 1.0f);
    for (int n = 0; n < 7; n++)
        data->event[n] = Tiler::Register(PNG_TITLEEVENT[n],
                                         eventsize[n], ivec2(0), 1.0f);
    data->state = TitleData::IDLE;
    data->period = TitleData::DAY;
    data->nextperiod = TitleData::DAY;
    data->timer = RandF(2000.0f, 3000.0f);
    /* Time needed for the eagle to cross the screen */
    data->eagle.duration = (bbox[1].x - bbox[0].x + 16) * STEP_EAGLE;
    data->eagle.timer = RandF(data->eagle.duration, 4 * data->eagle.duration);

    for (int n = 0; n < MAX_CLOUDS; n++)
    {
        data->cloudpos[n] = vec2(RandF((bbox[1] - bbox[0]).x),
                                 RandF(80) + (bbox[1] - bbox[0]).y - 300);
        data->cloudspeed[n] = vec2(RandF(-0.01f, 0.01f));
    }

    data->eagle.y = 140 + rand() % 40;

    data->gradient = new Gradient(vec3(0.0f, 0.0f, 0.0f),
                                  vec3(640.0f, 480.0f, 0.0f));
    Ticker::Ref(data->gradient);

    Input::TrackMouse(this);
}

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

    data->timer -= deltams;
    data->eagle.timer -= deltams;

    /* Probability of playing an animation given the current period */
    static float const p1[] = { 0.6f, 0.3f, 0.0f, 0.2f };
    /* Probability of a period change given the current period */
    static float const p2[] = { 0.1f, 0.2f, 0.5f, 0.5f };
    /* Number of frames in transition anims and events */
    static int const t1[] = { 31, 26, 7, 7, 32, 6, 31 };
    static int const t2[] = { 2, 4, 11, 4, 6, 2 };

    for (int n = 0; n < MAX_CLOUDS; n++)
    {
        float wrap = bbox[1].x - bbox[0].x;
        data->cloudpos[n].x += deltams * data->cloudspeed[n].x;
        if (data->cloudpos[n].x > wrap)
            data->cloudpos[n].x -= wrap;
        else if (data->cloudpos[n].x < 0.0f)
            data->cloudpos[n].x += wrap;
    }

    switch (data->state)
    {
    case TitleData::IDLE:
        if (data->eagle.timer < 0.0f)
        {
            data->eagle.timer = RandF(data->eagle.duration, 4 * data->eagle.duration);
            data->eagle.y = 140 + rand() % 40;
        }
        if (data->timer > 0.0f)
            break;
        if (RandF() < p1[data->period])
        {
            switch (data->period)
            {
            case TitleData::DAY:
                data->animid = rand() % 4;
                break;
            case TitleData::NIGHT:
                data->animid = (rand() % 2) ? 4 : 6;
                break;
            case TitleData::STEALTH:
                /* XXX: we should not be here! */
                break;
            case TitleData::RADIO:
                data->animid = 5;
                break;
            }
            data->state = TitleData::EVENT;
            data->nframes = t1[data->animid];
            data->timer = data->length = data->nframes * 100.0f;
        }
        else if (RandF() < p2[data->period])
        {
            switch (data->period)
            {
            case TitleData::DAY:
                data->nextperiod = TitleData::NIGHT;
                data->animid = 0;
                break;
            case TitleData::NIGHT:
                if (RandF() < 0.6f)
                {
                    data->nextperiod = TitleData::DAY;
                    data->animid = 5;
                }
                else
                {
                    data->nextperiod = TitleData::STEALTH;
                    data->animid = 1;
                }
                break;
            case TitleData::STEALTH:
                if (RandF() < 0.3f)
                {
                    data->nextperiod = TitleData::RADIO;
                    data->animid = 2;
                }
                else
                {
                    data->nextperiod = TitleData::NIGHT;
                    data->animid = 4;
                }
                break;
            case TitleData::RADIO:
                data->nextperiod = TitleData::STEALTH;
                data->animid = 3;
                break;
            }
            data->state = TitleData::ANIM;
            data->nframes = t2[data->animid];
            data->timer = data->length = data->nframes * 100.0f;
        }
        else
        {
            data->timer = RandF(500.0f, 1000.0f);
        }
        break;
    case TitleData::ANIM:
        if (data->timer < 0.0f)
            data->period = data->nextperiod;
            /* Fall through */
    case TitleData::EVENT:
        if (data->timer < 0.0f)
        {
            data->state = TitleData::IDLE;
            data->timer = RandF(500.0f, 1000.0f);
        }
        break;
    }
}

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

    /* The background, always here. */
    int backid = (int)data->period;
    Scene::GetDefault()->AddTile(data->title, backid,
                    ivec3(data->ground_pos.x, data->ground_pos.y, 1), 0);

    /* The stars */
    if (data->period != TitleData::DAY)
    {
        Scene::GetDefault()->AddTile(data->stars, 0,
                                     ivec3(24 + 0, 72 + 240, 2), 0);
    }

    /* The clouds. FIXME: tune color grading later */
    int cloudoff = data->period == TitleData::DAY ? 0 : 3;

    for (int n = 0; n < MAX_CLOUDS; n++)
    {
        /* There are only 5 cloud sprites */
        int cloudid = (n % 5) * 4 + cloudoff;
        Scene::GetDefault()->AddTile(data->clouds, cloudid,
                                     ivec3(data->cloudpos[n].x,
                                           data->cloudpos[n].y, 2), 0);
        Scene::GetDefault()->AddTile(data->clouds, cloudid,
                                     ivec3(data->cloudpos[n].x - bbox[1].x
                                                               + bbox[0].x,
                                           data->cloudpos[n].y, 2), 0);
    }

    /* Maybe an eagle? */
    if (data->eagle.timer >= 0.0f)
    {
        int eagleid = (int)(data->eagle.timer / 100) % 6;
        if (data->period != TitleData::DAY)
            eagleid += 6;
        float phase = sinf(data->eagle.timer * (2.0f * M_PI / 100 / 6));
        int x = (data->eagle.duration - data->eagle.timer) / STEP_EAGLE;
        int y = data->eagle.y + 5.0f * sinf(phase);
        Scene::GetDefault()->AddTile(data->eagle.tiles, eagleid,
                                     ivec3(24 + x, 72 + y, 3), 0);
    }

    /* The ground. */
    for (int x = (data->ground_pos.x - 1) % 384 - 384;
         x < Video::GetSize().x; x += 384)
    {
        Scene::GetDefault()->AddTile(data->ground, 0,
                                     ivec3(x, data->ground_pos.y, 0), 0);
    }

    /* The rocks */
    Scene::GetDefault()->AddTile(data->rocks, 0,
                                 ivec3(data->rocks_pos, 10), 0);

    /* Maybe an animation? */
    TileSet *tiler = NULL;
    int tileid = 0;
    ivec2 pos = ivec2(0);

    switch (data->state)
    {
    case TitleData::IDLE:
        break;
    case TitleData::ANIM:
        tiler = data->anim[data->animid];
        pos = animpos[data->animid];
        pos.y = 384 - animsize[data->animid].y - pos.y; // Hack
        tileid = (data->length - data->timer) * data->nframes / data->length;
        if (tileid < 0) tileid = 0;
        if (tileid > data->nframes - 1) tileid = data->nframes - 1;
        break;
    case TitleData::EVENT:
        tiler = data->event[data->animid];
        pos = eventpos[data->animid];
        pos.y = 384 - eventsize[data->animid].y - pos.y; // Hack
        tileid = (data->length - data->timer) * data->nframes / data->length;
        if (tileid < 0) tileid = 0;
        if (tileid > data->nframes - 1) tileid = data->nframes - 1;
        break;
    }
    if (tiler)
        Scene::GetDefault()->AddTile(tiler, tileid,
                                     ivec3(data->ground_pos.x + pos.x,
                                           data->ground_pos.y + pos.y, 1), 0);
}

int Title::IsClicked() const
{
    return clicked[0];
}

Title::~Title()
{
    Input::UntrackMouse(this);
    Ticker::Unref(data->logo_sprite);
    Tiler::Deregister(data->logo);
    Tiler::Deregister(data->ground);
    Tiler::Deregister(data->rocks);
    Tiler::Deregister(data->title);
    Tiler::Deregister(data->stars);
    Tiler::Deregister(data->clouds);
    Tiler::Deregister(data->eagle.tiles);
    for (int n = 0; n < 6; n++)
        Tiler::Deregister(data->anim[n]);
    for (int n = 0; n < 7; n++)
        Tiler::Deregister(data->event[n]);
    Ticker::Unref(data->gradient);
    delete data;
}