cl_sequence.c

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 UFO: Alien Invasion.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "client.h"
#include "cl_sequence.h"
#include "battlescape/cl_localentity.h"
#include "battlescape/cl_view.h"
#include "renderer/r_main.h"
#include "renderer/r_draw.h"
#include "renderer/r_mesh_anim.h"
#include "../shared/parse.h"
#include "ui/ui_main.h"
#include "ui/ui_nodes.h"
#include "ui/ui_render.h"

#define MAX_DATA_LENGTH 2048

struct sequenceContext_s;

typedef int (*sequenceHandler_t) (struct sequenceContext_s *context, const char *name, const char *data);

typedef struct seqCmd_s {
    sequenceHandler_t handler;
    char name[MAX_VAR];
    char data[MAX_DATA_LENGTH];
} seqCmd_t;

typedef struct sequence_s {
    char name[MAX_VAR]; 
    int start;      
    int length;     
} sequence_t;

typedef struct seqCamera_s {
    vec3_t origin;
    vec3_t speed;
    vec3_t angles;
    vec3_t omega;
    float dist;     
    float ddist;    
    float zoom;     
    float dzoom;    
} seqCamera_t;

typedef struct seqEnt_s {
    qboolean inuse;
    char name[MAX_VAR];
    model_t *model;     
    int skin;           
    vec3_t origin;      
    vec3_t speed;       
    vec3_t angles;      
    vec3_t omega;       
    vec3_t color;
    float alpha;
    char parent[MAX_VAR];   
    char tag[MAX_VAR];      
    animState_t as;         
    entity_t *ep;
} seqEnt_t;

typedef struct seq2D_s {
    qboolean inuse;         
    char name[MAX_VAR];     
    char *text;             
    char font[MAX_VAR];     
    char image[MAX_VAR];    
    vec2_t pos;         
    vec2_t speed;       
    vec2_t size;        
    vec2_t enlarge;     
    vec4_t color;       
    vec4_t fade;        
    vec4_t bgcolor;     
    align_t align;      
    qboolean relativePos;   
} seq2D_t;

#define MAX_SEQCMDS     8192
#define MAX_SEQUENCES   32
#define MAX_SEQENTS     128
#define MAX_SEQ2DS      128

static sequence_t sequences[MAX_SEQUENCES];
static int numSequences;

static seqCmd_t seqCmds[MAX_SEQCMDS];
static int numSeqCmds;

typedef struct sequenceContext_s {
    int time;
    qboolean endClickLoop;
    int currentCmd;
    int endCmd;
    cvar_t *animspeed;

    seqCamera_t camera;

    seqEnt_t ents[MAX_SEQENTS];
    int numEnts;

    seq2D_t obj2Ds[MAX_SEQ2DS];
    int numObj2Ds;

} sequenceContext_t;

static const value_t seqCamera_vals[] = {
    {"origin", V_VECTOR, offsetof(seqCamera_t, origin), MEMBER_SIZEOF(seqCamera_t, origin)},
    {"speed", V_VECTOR, offsetof(seqCamera_t, speed), MEMBER_SIZEOF(seqCamera_t, speed)},
    {"angles", V_VECTOR, offsetof(seqCamera_t, angles), MEMBER_SIZEOF(seqCamera_t, angles)},
    {"omega", V_VECTOR, offsetof(seqCamera_t, omega), MEMBER_SIZEOF(seqCamera_t, omega)},
    {"dist", V_FLOAT, offsetof(seqCamera_t, dist), MEMBER_SIZEOF(seqCamera_t, dist)},
    {"ddist", V_FLOAT, offsetof(seqCamera_t, ddist), MEMBER_SIZEOF(seqCamera_t, ddist)},
    {"zoom", V_FLOAT, offsetof(seqCamera_t, zoom), MEMBER_SIZEOF(seqCamera_t, zoom)},
    {"dzoom", V_FLOAT, offsetof(seqCamera_t, dzoom), MEMBER_SIZEOF(seqCamera_t, dzoom)},
    {NULL, 0, 0, 0}
};

static const value_t seqEnt_vals[] = {
    {"name", V_STRING, offsetof(seqEnt_t, name), 0},
    {"skin", V_INT, offsetof(seqEnt_t, skin), MEMBER_SIZEOF(seqEnt_t, skin)},
    {"alpha", V_FLOAT, offsetof(seqEnt_t, alpha), MEMBER_SIZEOF(seqEnt_t, alpha)},
    {"origin", V_VECTOR, offsetof(seqEnt_t, origin), MEMBER_SIZEOF(seqEnt_t, origin)},
    {"speed", V_VECTOR, offsetof(seqEnt_t, speed), MEMBER_SIZEOF(seqEnt_t, speed)},
    {"angles", V_VECTOR, offsetof(seqEnt_t, angles), MEMBER_SIZEOF(seqEnt_t, angles)},
    {"omega", V_VECTOR, offsetof(seqEnt_t, omega), MEMBER_SIZEOF(seqEnt_t, omega)},
    {"color", V_VECTOR, offsetof(seqEnt_t, color), MEMBER_SIZEOF(seqEnt_t, color)},
    {"parent", V_STRING, offsetof(seqEnt_t, parent), 0},
    {"tag", V_STRING, offsetof(seqEnt_t, tag), 0},
    {NULL, 0, 0, 0}
};

static const value_t seq2D_vals[] = {
    {"name", V_STRING, offsetof(seq2D_t, name), 0},
    {"text", V_TRANSLATION_STRING, offsetof(seq2D_t, text), 0},
    {"font", V_STRING, offsetof(seq2D_t, font), 0},
    {"image", V_STRING, offsetof(seq2D_t, image), 0},
    {"pos", V_POS, offsetof(seq2D_t, pos), MEMBER_SIZEOF(seq2D_t, pos)},
    {"speed", V_POS, offsetof(seq2D_t, speed), MEMBER_SIZEOF(seq2D_t, speed)},
    {"size", V_POS, offsetof(seq2D_t, size), MEMBER_SIZEOF(seq2D_t, size)},
    {"enlarge", V_POS, offsetof(seq2D_t, enlarge), MEMBER_SIZEOF(seq2D_t, enlarge)},
    {"bgcolor", V_COLOR, offsetof(seq2D_t, bgcolor), MEMBER_SIZEOF(seq2D_t, bgcolor)},
    {"color", V_COLOR, offsetof(seq2D_t, color), MEMBER_SIZEOF(seq2D_t, color)},
    {"fade", V_COLOR, offsetof(seq2D_t, fade), MEMBER_SIZEOF(seq2D_t, fade)},
    {"align", V_ALIGN, offsetof(seq2D_t, align), MEMBER_SIZEOF(seq2D_t, align)},
    {"relative", V_BOOL, offsetof(seq2D_t, relativePos), MEMBER_SIZEOF(seq2D_t, relativePos)},
    {NULL, 0, 0, 0},
};

static void SEQ_SetCamera (sequenceContext_t *context)
{
    if (!viddef.viewWidth || !viddef.viewHeight)
        return;

    /* advance time */
    VectorMA(context->camera.origin, cls.frametime, context->camera.speed, context->camera.origin);
    VectorMA(context->camera.angles, cls.frametime, context->camera.omega, context->camera.angles);
    context->camera.zoom += cls.frametime * context->camera.dzoom;
    context->camera.dist += cls.frametime * context->camera.ddist;

    /* set camera */
    VectorCopy(context->camera.origin, cl.cam.origin);
    VectorCopy(context->camera.angles, cl.cam.angles);

    AngleVectors(cl.cam.angles, cl.cam.axis[0], cl.cam.axis[1], cl.cam.axis[2]);
    VectorMA(cl.cam.origin, -context->camera.dist, cl.cam.axis[0], cl.cam.camorg);
    cl.cam.zoom = max(context->camera.zoom, MIN_ZOOM);
    /* fudge to get isometric and perspective modes looking similar */
    if (cl_isometric->integer)
        cl.cam.zoom /= 1.35;
    CL_ViewCalcFieldOfViewX();
}


static seqEnt_t *SEQ_FindEnt (sequenceContext_t *context, const char *name)
{
    seqEnt_t *se;
    int i;

    for (i = 0, se = context->ents; i < context->numEnts; i++, se++)
        if (se->inuse && !strncmp(se->name, name, MAX_VAR))
            break;
    if (i < context->numEnts)
        return se;
    else
        return NULL;
}


static seq2D_t *SEQ_Find2D (sequenceContext_t *context, const char *name)
{
    seq2D_t *s2d;
    int i;

    for (i = 0, s2d = context->obj2Ds; i < context->numObj2Ds; i++, s2d++)
        if (s2d->inuse && !strcmp(s2d->name, name))
            break;
    if (i < context->numObj2Ds)
        return s2d;
    else
        return NULL;
}

static void SEQ_Render3D (sequenceContext_t *context)
{
    entity_t ent;
    seqEnt_t *se;
    int i;

    /* set camera */
    SEQ_SetCamera(context);

    /* render sequence */
    for (i = 0, se = context->ents; i < context->numEnts; i++, se++)
        if (se->inuse) {
            /* advance in time */
            VectorMA(se->origin, cls.frametime, se->speed, se->origin);
            VectorMA(se->angles, cls.frametime, se->omega, se->angles);
            R_AnimRun(&se->as, se->model, context->animspeed->integer * cls.frametime);

            /* add to scene */
            memset(&ent, 0, sizeof(ent));
            ent.model = se->model;
            ent.skinnum = se->skin;
            ent.as = se->as;
            ent.alpha = se->alpha;

            R_EntitySetOrigin(&ent, se->origin);
            VectorCopy(se->origin, ent.oldorigin);
            VectorCopy(se->angles, ent.angles);

            if (se->parent && se->tag) {
                seqEnt_t *parent;

                parent = SEQ_FindEnt(context, se->parent);
                if (parent)
                    ent.tagent = parent->ep;
                ent.tagname = se->tag;
            }

            /* add to render list */
            se->ep = R_GetFreeEntity();
            R_AddEntity(&ent);
        }
}


static void SEQ_Render2D (sequenceContext_t *context)
{
    seq2D_t *s2d;
    int i, j;
    int height = 0;
    vec3_t pos;

    /* center screen */
    pos[0] = (viddef.virtualWidth - VID_NORM_WIDTH) / 2;
    pos[1] = (viddef.virtualHeight - VID_NORM_HEIGHT) / 2;
    pos[2] = 0;
    UI_Transform(pos, NULL, NULL);

    /* add texts */
    for (i = 0, s2d = context->obj2Ds; i < context->numObj2Ds; i++, s2d++)
        if (s2d->inuse) {
            if (s2d->relativePos && height > 0) {
                s2d->pos[1] += height;
                s2d->relativePos = qfalse;
            }
            /* advance in time */
            for (j = 0; j < 4; j++) {
                s2d->color[j] += cls.frametime * s2d->fade[j];
                if (s2d->color[j] < 0.0)
                    s2d->color[j] = 0.0;
                else if (s2d->color[j] > 1.0)
                    s2d->color[j] = 1.0;
            }
            for (j = 0; j < 2; j++) {
                s2d->pos[j] += cls.frametime * s2d->speed[j];
                s2d->size[j] += cls.frametime * s2d->enlarge[j];
            }

            /* outside the screen? */
            /*if (s2d->pos[1] >= VID_NORM_HEIGHT || s2d->pos[0] >= VID_NORM_WIDTH)
                continue;*/

            /* render */
            R_Color(s2d->color);

            /* image can be background */
            if (s2d->image[0] != '\0') {
                const image_t *image = R_FindImage(s2d->image, it_pic);
                R_DrawImage(s2d->pos[0], s2d->pos[1], image);
            }

            /* bgcolor can be overlay */
            if (s2d->bgcolor[3] > 0.0)
                R_DrawFill(s2d->pos[0], s2d->pos[1], s2d->size[0], s2d->size[1], s2d->bgcolor);

            /* render */
            R_Color(s2d->color);

            /* gettext placeholder */
            if (s2d->text) {
                int maxWidth = (int) s2d->size[0];
                if (maxWidth <= 0)
                    maxWidth = VID_NORM_WIDTH;
                height += UI_DrawString(s2d->font, s2d->align, s2d->pos[0], s2d->pos[1], s2d->pos[0], maxWidth, -1 , _(s2d->text), 0, 0, NULL, qfalse, LONGLINES_WRAP);
            }
        }
    R_Color(NULL);

    UI_Transform(NULL, NULL, NULL);
}

static void SEQ_ClickEvent (sequenceContext_t *context)
{
    context->endClickLoop = qtrue;
}

static qboolean SEQ_InitSequence (sequenceContext_t *context, const char *name)
{
    sequence_t *sp;
    int i;

    /* find sequence */
    for (i = 0, sp = sequences; i < numSequences; i++, sp++)
        if (!strcmp(name, sp->name))
            break;
    if (i >= numSequences) {
        Com_Printf("Couldn't find sequence '%s'\n", name);
        return qfalse;
    }

    memset(context, 0, sizeof(*context));
    context->numEnts = 0;
    context->numObj2Ds = 0;
    context->time = cl.time;
    context->currentCmd = sp->start;
    context->endCmd = sp->start + sp->length;
    context->animspeed = Cvar_Get("seq_animspeed", "1000", 0, NULL);

    return qtrue;
}

static void SEQ_StopSequence (sequenceContext_t *context)
{
    context->endClickLoop = qtrue;
}

static qboolean SEQ_Execute (sequenceContext_t *context)
{
    seqCmd_t *sc;

    /* we are inside a waiting command */
    if (context->time > cl.time) {
        /* if we clicked a button we end the waiting loop */
        if (context->endClickLoop) {
            context->time = cl.time;
            context->endClickLoop = qfalse;
        }
    }

    /* run script */
    while (context->time <= cl.time) {
        /* test for finish */
        if (context->currentCmd >= context->endCmd) {
            SEQ_StopSequence(context);
            return qfalse;
        }

        /* call handler */
        sc = &seqCmds[context->currentCmd];
        context->currentCmd += sc->handler(context, sc->name, sc->data);
    }

    return qtrue;
}

/* =========================================================== */

static int SEQ_ExecuteClick (sequenceContext_t *context, const char *name, const char *data)
{
    /* if a CL_SequenceClick_f event was called */
    if (context->endClickLoop) {
        context->endClickLoop = qfalse;
        /* increase the command counter by 1 */
        return 1;
    }
    context->time += 1000;
    /* don't increase the command counter - stay at click command */
    return 0;
}

static int SEQ_ExecuteWait (sequenceContext_t *context, const char *name, const char *data)
{
    context->time += 1000 * atof(name);
    return 1;
}

static int SEQ_ExecutePrecache (sequenceContext_t *context, const char *name, const char *data)
{
    if (!strcmp(name, "models")) {
        while (*data) {
            Com_DPrintf(DEBUG_CLIENT, "Precaching model: %s\n", data);
            R_RegisterModelShort(data);
            data += strlen(data) + 1;
        }
    } else if (!strcmp(name, "pics")) {
        while (*data) {
            Com_DPrintf(DEBUG_CLIENT, "Precaching image: %s\n", data);
            R_RegisterImage(data);
            data += strlen(data) + 1;
        }
    } else
        Com_Printf("SEQ_Precache: unknown format '%s'\n", name);
    return 1;
}

static int SEQ_ExecuteCamera (sequenceContext_t *context, const char *name, const char *data)
{
    /* get values */
    while (*data) {
        const value_t *vp;
        for (vp = seqCamera_vals; vp->string; vp++)
            if (!strcmp(data, vp->string)) {
                data += strlen(data) + 1;
                Com_EParseValue(&context->camera, data, vp->type, vp->ofs, vp->size);
                break;
            }
        if (!vp->string)
            Com_Printf("SEQ_Camera: unknown token '%s'\n", data);

        data += strlen(data) + 1;
    }
    return 1;
}

static int SEQ_ExecuteModel (sequenceContext_t *context, const char *name, const char *data)
{
    /* get sequence entity */
    seqEnt_t *se = SEQ_FindEnt(context, name);
    if (!se) {
        int i;
        /* create new sequence entity */
        for (i = 0, se = context->ents; i < context->numEnts; i++, se++)
            if (!se->inuse)
                break;
        if (i >= context->numEnts) {
            if (context->numEnts >= MAX_SEQENTS)
                Com_Error(ERR_FATAL, "Too many sequence entities");
            se = &context->ents[context->numEnts++];
        }
        /* allocate */
        memset(se, 0, sizeof(*se));
        se->inuse = qtrue;
        Q_strncpyz(se->name, name, sizeof(se->name));
        VectorSet(se->color, 0.7, 0.7, 0.7);
    }

    /* get values */
    while (*data) {
        const value_t *vp;
        for (vp = seqEnt_vals; vp->string; vp++)
            if (!strcmp(data, vp->string)) {
                data += strlen(data) + 1;
                Com_EParseValue(se, data, vp->type, vp->ofs, vp->size);
                break;
            }
        if (!vp->string) {
            if (!strcmp(data, "model")) {
                data += strlen(data) + 1;
                Com_DPrintf(DEBUG_CLIENT, "Registering model: %s\n", data);
                se->model = R_RegisterModelShort(data);
            } else if (!strcmp(data, "anim")) {
                data += strlen(data) + 1;
                Com_DPrintf(DEBUG_CLIENT, "Change anim to: %s\n", data);
                R_AnimChange(&se->as, se->model, data);
            } else
                Com_Printf("SEQ_Model: unknown token '%s'\n", data);
        }

        data += strlen(data) + 1;
    }
    return 1;
}

static int SEQ_ExecuteMusic (sequenceContext_t *context, const char *name, const char *data)
{
    Com_Printf("change music to %s\n", name);
    Cvar_Set("snd_music", name);
    return 1;
}

static int SEQ_ExecuteSound (sequenceContext_t *context, const char *name, const char *data)
{
    S_StartLocalSample(name, SND_VOLUME_DEFAULT);
    return 1;
}

static int SEQ_Execute2Dobj (sequenceContext_t *context, const char *name, const char *data)
{
    seq2D_t *s2d;
    const value_t *vp;
    int i;

    /* get sequence text */
    s2d = SEQ_Find2D(context, name);
    if (!s2d) {
        /* create new sequence text */
        for (i = 0, s2d = context->obj2Ds; i < context->numObj2Ds; i++, s2d++)
            if (!s2d->inuse)
                break;
        if (i >= context->numObj2Ds) {
            if (context->numObj2Ds >= MAX_SEQ2DS)
                Com_Error(ERR_FATAL, "Too many sequence 2d objects");
            s2d = &context->obj2Ds[context->numObj2Ds++];
        }
        /* allocate */
        memset(s2d, 0, sizeof(*s2d));
        for (i = 0; i < 4; i++)
            s2d->color[i] = 1.0f;
        s2d->inuse = qtrue;
        Q_strncpyz(s2d->font, "f_big", sizeof(s2d->font));  /* default font */
        Q_strncpyz(s2d->name, name, sizeof(s2d->name));
    }

    /* get values */
    while (*data) {
        for (vp = seq2D_vals; vp->string; vp++)
            if (!strcmp(data, vp->string)) {
                data += strlen(data) + 1;
                switch (vp->type) {
                case V_TRANSLATION_STRING:
                    data++;
                case V_CLIENT_HUNK_STRING:
                    Mem_PoolStrDupTo(data, (char**) ((char*)s2d + (int)vp->ofs), cl_genericPool, 0);
                    break;

                default:
                    Com_EParseValue(s2d, data, vp->type, vp->ofs, vp->size);
                    break;
                }
                break;
            }
        if (!vp->string)
            Com_Printf("SEQ_Text: unknown token '%s'\n", data);

        data += strlen(data) + 1;
    }
    return 1;
}

static int SEQ_ExecuteRemove (sequenceContext_t *context, const char *name, const char *data)
{
    seqEnt_t *se;
    seq2D_t *s2d;

    se = SEQ_FindEnt(context, name);
    if (se)
        se->inuse = qfalse;

    s2d = SEQ_Find2D(context, name);
    if (s2d) {
        s2d->inuse = qfalse;

        if (s2d->text) {
            Mem_Free(s2d->text);
            s2d->text = NULL;
        }
    }

    if (!se && !s2d)
        Com_Printf("SEQ_Remove: couldn't find '%s'\n", name);
    return 1;
}

static int SEQ_ExecuteCommand (sequenceContext_t *context, const char *name, const char *data)
{
    /* add the command */
    Cbuf_AddText(name);
    return 1;
}

/* =========================================================== */

sequenceContext_t seq;

static void CL_SequenceClick_f (void)
{
    SEQ_ClickEvent(&seq);
}

static void CL_SequenceStart_f (void)
{
    const char *name, *menuName;
    const uiNode_t* menu;

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <name> [<menu>]\n", Cmd_Argv(0));
        return;
    }
    name = Cmd_Argv(1);

    if (!SEQ_InitSequence(&seq, name))
        return;

    /* display the sequence menu */
    /* the default is in menu_main.ufo - menu sequence */
    menuName = Cmd_Argc() < 3 ? mn_sequence->string : Cmd_Argv(2);
    menu = UI_PushWindow(menuName, NULL);
    if (!menu) {
        Com_Printf("CL_SequenceStart_f: can't display menu '%s'\n", menuName);
        return;
    }

    /* If running a local server, kill it */
    SV_Shutdown("Server quit", qfalse);
    /* if still connected - disconnect */
    CL_Disconnect();

    /* init sequence state */
    CL_SetClientState(ca_sequence);
}

static void CL_SequenceEnd_f (void)
{
    if (cls.state == ca_sequence)
        CL_SetClientState(ca_disconnected);
}

void CL_SequenceRender (void)
{
    refdef.brushCount = 0;
    refdef.aliasCount = 0;

    if (!viddef.viewWidth || !viddef.viewHeight)
        return;

    /* still loading */
    if (!refdef.ready)
        return;

    if (!SEQ_Execute(&seq)) {
        CL_SequenceEnd_f();
        UI_PopWindow(qfalse);
        return;
    }

    refdef.numEntities = 0;
    refdef.mapTiles = cl.mapTiles;

    SEQ_Render3D(&seq);

    refdef.rendererFlags |= RDF_NOWORLDMODEL;

    /* update ref def */
    CL_ViewUpdateRenderData();

    /* render the world */
    R_RenderFrame();

    SEQ_Render2D(&seq);
}

void SEQ_InitStartup (void)
{
    Cmd_AddCommand("seq_click", CL_SequenceClick_f, NULL);
    Cmd_AddCommand("seq_start", CL_SequenceStart_f, NULL);
    Cmd_AddCommand("seq_end", CL_SequenceEnd_f, NULL);
}


/* =========================================================== */

static const char *seqCmdName[] = {
    "end",
    "wait",
    "click",
    "precache",
    "camera",
    "model",
    "2dobj",
    "music",
    "sound",
    "rem",
    "cmd"
};

#define SEQ_NUMCMDS lengthof(seqCmdName)

static sequenceHandler_t seqCmdFunc[] = {
    NULL,
    SEQ_ExecuteWait,
    SEQ_ExecuteClick,
    SEQ_ExecutePrecache,
    SEQ_ExecuteCamera,
    SEQ_ExecuteModel,
    SEQ_Execute2Dobj,
    SEQ_ExecuteMusic,
    SEQ_ExecuteSound,
    SEQ_ExecuteRemove,
    SEQ_ExecuteCommand
};
CASSERT(lengthof(seqCmdFunc) == lengthof(seqCmdName));

void CL_ParseSequence (const char *name, const char **text)
{
    const char *errhead = "CL_ParseSequence: unexpected end of file (sequence ";
    sequence_t *sp;
    const char *token;
    int i;

    /* search for sequences with same name */
    for (i = 0; i < numSequences; i++)
        if (!strcmp(name, sequences[i].name))
            break;

    if (i < numSequences) {
        Com_Printf("CL_ParseSequence: sequence def \"%s\" with same name found, second ignored\n", name);
        return;
    }

    /* initialize the sequence */
    if (numSequences >= MAX_SEQUENCES)
        Com_Error(ERR_FATAL, "Too many sequences");

    sp = &sequences[numSequences++];
    memset(sp, 0, sizeof(*sp));
    Q_strncpyz(sp->name, name, sizeof(sp->name));
    sp->start = numSeqCmds;

    /* get it's body */
    token = Com_Parse(text);

    if (!*text || *token != '{') {
        Com_Printf("CL_ParseSequence: sequence def \"%s\" without body ignored\n", name);
        numSequences--;
        return;
    }

    do {
        token = Com_EParse(text, errhead, name);
        if (!*text)
            break;
    next_cmd:
        if (*token == '}')
            break;

        /* check for commands */
        for (i = 0; i < SEQ_NUMCMDS; i++)
            if (!strcmp(token, seqCmdName[i])) {
                int maxLength = MAX_DATA_LENGTH;
                int depth;
                char *data;
                seqCmd_t *sc;

                /* found a command */
                token = Com_EParse(text, errhead, name);
                if (!*text)
                    return;

                if (numSeqCmds >= MAX_SEQCMDS)
                    Com_Error(ERR_FATAL, "Too many sequence commands");

                /* init seqCmd */
                sc = &seqCmds[numSeqCmds++];
                memset(sc, 0, sizeof(*sc));
                sc->handler = seqCmdFunc[i];
                sp->length++;

                /* copy name */
                Q_strncpyz(sc->name, token, sizeof(sc->name));

                /* read data */
                token = Com_EParse(text, errhead, name);
                if (!*text)
                    return;
                if (*token != '{')
                    goto next_cmd;

                depth = 1;
                data = &sc->data[0];
                while (depth) {
                    if (maxLength <= 0) {
                        Com_Printf("Too much data for sequence %s", sc->name);
                        break;
                    }
                    token = Com_EParse(text, errhead, name);
                    if (!*text)
                        return;

                    if (*token == '{')
                        depth++;
                    else if (*token == '}')
                        depth--;
                    if (depth) {
                        Q_strncpyz(data, token, maxLength);
                        data += strlen(token) + 1;
                        maxLength -= (strlen(token) + 1);
                    }
                }
                break;
            }

        if (i == SEQ_NUMCMDS) {
            Com_Printf("CL_ParseSequence: unknown command \"%s\" ignored (sequence %s)\n", token, name);
            Com_EParse(text, errhead, name);
        }
    } while (*text);
}