n_anim.c

Go to the documentation of this file.

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include "nilorea/n_anim.h"
 
#include "math.h"
 
ANIM_LIB* create_anim_library(const char* name, unsigned int size) {
    if (size < 1) {
        n_log(LOG_ERR, "Invalid size (<1) for anim lib creation");
        return NULL;
    }
 
    ANIM_LIB* lib = NULL;
    Malloc(lib, ANIM_LIB, 1);
    __n_assert(lib, return NULL);
 
    lib->gfxs = NULL;
    Malloc(lib->gfxs, ANIM_GFX*, size);
    if (!lib->gfxs) {
        n_log(LOG_ERR, "Unable to allocate a gfx_lib of size %d", size);
        Free(lib);
        return NULL;
    }
 
    if (name)
        lib->name = strdup(name);
    else
        lib->name = strdup("generic-name");
 
    lib->nb_max_gfxs = size;
 
    return lib;
} /* create_anim_lib */
 
int destroy_anim_lib(ANIM_LIB** lib) {
    __n_assert((*lib), return FALSE);
 
    for (uint32_t it = 0; it < (*lib)->nb_max_gfxs; it++) {
        if ((*lib)->gfxs[it]) {
            FreeNoLog((*lib)->gfxs[it]->frames);
            if ((*lib)->gfxs[it]->bmp) al_destroy_bitmap((*lib)->gfxs[it]->bmp);
        }
        FreeNoLog((*lib)->gfxs[it]);
    }
    Free((*lib)->gfxs);
    FreeNoLog((*lib)->name);
    Free((*lib));
    return TRUE;
} /* destroy_anim_lib */
 
int delete_bmp_from_lib(ANIM_LIB* lib, unsigned int id) {
    __n_assert(lib, return FALSE);
    __n_assert(lib->gfxs, return FALSE);
 
    if (id >= lib->nb_max_gfxs) return FALSE;
    if (lib->gfxs[id]) {
        FreeNoLog(lib->gfxs[id]->frames);
        if (lib->gfxs[id]->bmp) al_destroy_bitmap(lib->gfxs[id]->bmp);
        FreeNoLog(lib->gfxs[id]);
    }
    return TRUE;
} /* delete anim from lib */
 
int add_bmp_to_lib(ANIM_LIB* lib, unsigned int pos, char* file, char* resfile) {
    __n_assert(lib, return FALSE);
    __n_assert(file, return FALSE);
    __n_assert(resfile, return FALSE);
 
    if (pos >= lib->nb_max_gfxs) {
        n_log(LOG_ERR, "invalid position %d, can only go from 0 to %d in anim lib %s", pos, lib->nb_max_gfxs, lib->name);
        return FALSE;
    }
    if (lib->gfxs[pos] != NULL) {
        n_log(LOG_ERR, "there already is a gfx at pos %d in anim lib %s", pos, lib->name);
        return FALSE;
    }
 
    FILE* data = fopen(resfile, "r");
    if (!data) {
        n_log(LOG_ERR, "Unable to open %s !", resfile);
        return FALSE;
    }
 
    int check_id = 0;
    int check_fscanf = 0;
    ANIM_GFX* gfx = NULL;
 
    check_fscanf = fscanf(data, "%d", &check_id);
    if (check_fscanf == 1 && check_id == 211282) {
        Malloc(gfx, ANIM_GFX, 1);
        __n_assert(gfx, fclose(data); return FALSE);
    } else {
        n_log(LOG_ERR, "file %s: invalid check_id of %d, should be 211282", resfile, check_id);
        fclose(data);
        return FALSE;
    }
 
    if (fscanf(data, "%u %u %u", &gfx->w, &gfx->h, &gfx->nb_frames) != 3) {
        n_log(LOG_ERR, "file %s: invalid &gfx -> w, &gfx -> h, &gfx -> nb_frames !", resfile);
        Free(gfx);
        fclose(data);
        return FALSE;
    }
 
    if (gfx->nb_frames >= UINT_MAX) {
        n_log(LOG_ERR, "file %s: invalid number of frames: %u", resfile, gfx->nb_frames);
        Free(gfx);
        fclose(data);
        return FALSE;
    }
    // file stores last_frame_index (0-based), convert to count
    gfx->nb_frames += 1;
 
    Malloc(gfx->frames, ANIM_FRAME, gfx->nb_frames);
    if (!gfx->frames) {
        n_log(LOG_ERR, "file %s: could not allocate %d frames", resfile, gfx->nb_frames);
        Free(gfx);
        fclose(data);
        return FALSE;
    }
 
    gfx->bmp = al_load_bitmap(file);
    if (!gfx->bmp) {
        n_log(LOG_ERR, "file %s: unable to load image", file);
        Free(gfx->frames);
        Free(gfx);
        fclose(data);
        return FALSE;
    }
 
    for (unsigned int it = 0; it < gfx->nb_frames; it++) {
        if (fscanf(data, "%d %d %u", &gfx->frames[it].x, &gfx->frames[it].y, &gfx->frames[it].duration) != 3) {
            n_log(LOG_ERR, "file %s: invalid &gfx -> frames[ %d ].x, &gfx -> frames[ %d ].y, &gfx -> frames[ %d ] . duration !", resfile, it, it, it);
            Free(gfx->frames);
            Free(gfx);
            fclose(data);
            return FALSE;
        }
    }
    fclose(data);
 
    lib->gfxs[pos] = gfx;
 
    return TRUE;
} /* add_bmp_to_lib( ... ) */
 
int update_anim(ANIM_DATA* data, unsigned int delta_t) {
    __n_assert(data, return FALSE);
 
    // single-frame sprite, nothing to update
    if (data->lib->gfxs[data->id]->nb_frames <= 1)
        return TRUE;
 
    data->elapsed += delta_t;
    if (data->elapsed > data->lib->gfxs[data->id]->frames[data->frame].duration) {
        data->elapsed = 0;
        data->frame++;
        if (data->frame >= data->lib->gfxs[data->id]->nb_frames)
            data->frame = 0;
    }
    return TRUE;
} /* update_anim( ... ) */
 
int draw_anim(ANIM_DATA* data, int x, int y) {
    ALLEGRO_BITMAP* bmp = data->lib->gfxs[data->id]->bmp;
 
    unsigned int tilew = data->lib->gfxs[data->id]->w;
    unsigned int tileh = data->lib->gfxs[data->id]->h;
 
    int px = data->lib->gfxs[data->id]->frames[data->frame].x;
    int py = data->lib->gfxs[data->id]->frames[data->frame].y;
 
    unsigned int framex = data->frame * tilew;
 
    al_draw_bitmap_region(bmp, (float)framex, 0, (float)tilew, (float)tileh, (float)(x - px), (float)(y - py), 0);
 
    return TRUE;
}
/* draw_anim( ... ) */