image.c

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */

#include "global.h"

#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "image.h"

Face *new_faces;

const Face *blank_face, *empty_face, *smooth_face;


static unsigned int nrofpixmaps = 0;

face_sets facesets[MAX_FACE_SETS];    
static const char *const colorname[] = {
    "black",        /* 0  */
    "white",        /* 1  */
    "blue",         /* 2  */
    "red",          /* 3  */
    "orange",       /* 4  */
    "light_blue",   /* 5  */
    "dark_orange",  /* 6  */
    "green",        /* 7  */
    "light_green",  /* 8  */
    "grey",         /* 9  */
    "brown",        /* 10 */
    "yellow",       /* 11 */
    "khaki"         /* 12 */
};

static int compare_face(const Face *a, const Face *b) {
    if (strcmp(a->name, "bug.111") == 0) {
        if (strcmp(b->name, "bug.111") == 0)
            return 0;
        return -1;
    } else if (strcmp(b->name, "bug.111") == 0)
        return 1;
    return strcmp(a->name, b->name);
}

static Face *internal_find_face(const char *name) {
    Face *bp, tmp;

    tmp.name = name;
    bp = (Face *)bsearch(&tmp, new_faces, nrofpixmaps, sizeof(Face), (int (*)(const void *, const void *))compare_face);

    return bp;
}

static uint8_t find_color(const char *name) {
    uint8_t i;

    for (i = 0; i < sizeof(colorname)/sizeof(*colorname); i++)
        if (!strcmp(name, colorname[i]))
            return i;

    LOG(llevError, "Unknown color: %s\n", name);
    return 0;
}

static void read_face_data(void) {
    char buf[MAX_BUF], *cp;
    Face *on_face = NULL;
    FILE *fp;

    snprintf(buf, sizeof(buf), "%s/faces", settings.datadir);
    if ((fp = fopen(buf, "r")) == NULL) {
        LOG(llevError, "faces: couldn't open file: %s\n", strerror(errno));
        exit(-1);
    }

    while (fgets(buf, MAX_BUF, fp) != NULL) {
        if (*buf == '#')
            continue;
        if (!strncmp(buf, "end", 3)) {
            on_face = NULL;
        } else if (!strncmp(buf, "face", 4)) {
            Face *tmp;

            cp = buf+5;
            cp[strlen(cp)-1] = '\0'; /* remove newline */

            if ((tmp = internal_find_face(cp)) == NULL) {
                LOG(llevError, "faces: couldn't find '%s'\n", cp);
                on_face = NULL;
                continue;
            }
            on_face = tmp;
            on_face->visibility = 0;
        } else if (on_face == NULL) {
            LOG(llevError, "faces: got line with no face set: %s\n", buf);
        } else if (!strncmp(buf, "visibility", 10)) {
            on_face->visibility = atoi(buf+11);
        } else if (!strncmp(buf, "magicmap", 8)) {
            cp = buf+9;
            cp[strlen(cp)-1] = '\0';
            on_face->magicmap = find_color(cp);
        } else if (!strncmp(buf, "is_floor", 8)) {
            int value = atoi(buf+9);
            if (value)
                on_face->magicmap |= FACE_FLOOR;
        } else
            LOG(llevDebug, "faces: unknown line in %s\n", buf);
    }
    fclose(fp);
}

void read_bmap_names(void) {
    char buf[MAX_BUF], *p;
    FILE *fp;
    unsigned int i;
    size_t l;

    bmaps_checksum = 0;
    snprintf(buf, sizeof(buf), "%s/bmaps.paths", settings.datadir);
    if ((fp = fopen(buf, "r")) == NULL) {
        LOG(llevError, "bmaps: couldn't open: %s\n", strerror(errno));
        exit(-1);
    }

    nrofpixmaps = 0;

    /* First count how many bitmaps we have, so we can allocate correctly */
    while (fgets(buf, MAX_BUF, fp) != NULL) {
        if (buf[0] != '#' && buf[0] != '\n') {
            nrofpixmaps++;
        }
    }

    rewind(fp);
    assert(nrofpixmaps > 0);
    new_faces = (Face *)malloc(sizeof(Face)*nrofpixmaps);
    if (new_faces == NULL) {
        fatal(OUT_OF_MEMORY);
    }

    for (i = 0; i < nrofpixmaps; i++) {
        new_faces[i].name = NULL;
        new_faces[i].visibility = 0;
        new_faces[i].magicmap = 255;
        new_faces[i].smoothface = NULL;
    }

    i = 0;
    while (i < nrofpixmaps && fgets(buf, MAX_BUF, fp) != NULL) {
        if (*buf == '#')
            continue;

        p = strrchr(buf, '/');
        if ((p == NULL) || (strtok(p, " \t\n") == NULL)) {
            LOG(llevError, "bmaps: syntax error in %s\n", buf);
            fatal(SEE_LAST_ERROR);
        }
        /* strtok converted the final newline or tab to NULL so all is ok */
        new_faces[i].name = strdup_local(p + 1);

        /* We need to calculate the checksum of the bmaps file
         * name->number mapping to send to the client.  This does not
         * need to match what sum or other utility may come up with -
         * as long as we get the same results on the same real file
         * data, it does the job as it lets the client know if
         * the file has the same data or not.
         */
        ROTATE_RIGHT(bmaps_checksum);
        bmaps_checksum += i&0xff;
        bmaps_checksum &= 0xffffffff;

        ROTATE_RIGHT(bmaps_checksum);
        bmaps_checksum += (i>>8)&0xff;
        bmaps_checksum &= 0xffffffff;
        for (l = 0; l < strlen(p); l++) {
            ROTATE_RIGHT(bmaps_checksum);
            bmaps_checksum += p[l];
            bmaps_checksum &= 0xffffffff;
        }

        i++;
    }
    fclose(fp);

    if (i != nrofpixmaps) {
        LOG(llevError, "read_bmap_names: first read gave %d faces but only loaded %d??\n", nrofpixmaps, i);
        fatal(SEE_LAST_ERROR);
    }

    LOG(llevDebug, "bmaps: loaded %d faces\n", nrofpixmaps);

    qsort(new_faces, nrofpixmaps, sizeof(Face), (int (*)(const void *, const void *))compare_face);

    for (i = 0; i < nrofpixmaps; i++) {
        new_faces[i].number = i;
    }

    read_face_data();

    for (i = 0; i < nrofpixmaps; i++) {
        if (new_faces[i].magicmap == 255) {
            new_faces[i].magicmap = 0;
        }
    }
    /* Actually forcefully setting the colors here probably should not
     * be done - it could easily create confusion.
     */
    blank_face = internal_find_face(BLANK_FACE_NAME);
    ((Face*)blank_face)->magicmap = find_color("khaki")|FACE_FLOOR; // TODO: doh :(

    empty_face = internal_find_face(EMPTY_FACE_NAME);

    smooth_face = internal_find_face(SMOOTH_FACE_NAME);
}

const Face *find_face(const char *name, const Face *error) {
    const Face *bp = internal_find_face(name);
    return bp ? bp : error;
}

int read_smooth(void) {
    char buf[MAX_BUF], *p, *q;
    FILE *fp;
    Face *regular, *smoothed;
    int nrofsmooth = 0;

    snprintf(buf, sizeof(buf), "%s/smooth", settings.datadir);
    if ((fp = fopen(buf, "r")) == NULL) {
        LOG(llevError, "Cannot open smooth file: %s\n", strerror(errno));
        exit(-1);
    }

    while (fgets(buf, MAX_BUF, fp) != NULL) {
        if (*buf == '#')
            continue;

        if ((p = strchr(buf, '\n')))
            *p = '\0';

        p = strchr(buf, ' ');
        if (!p)
            continue;

        *p = '\0';
        q = buf;
        regular = internal_find_face(q);
        if (regular == NULL) {
            LOG(llevError, "invalid regular face: %s\n", q);
            continue;
        }
        q = p+1;
        smoothed = internal_find_face(q);
        if (smoothed == NULL) {
            LOG(llevError, "invalid smoothed face: %s\n", q);
            continue;
        }

        regular->smoothface = smoothed;

        nrofsmooth++;
    }
    fclose(fp);

    LOG(llevDebug, "smooth: loaded %d entries\n", nrofsmooth);
    return nrofsmooth;
}

int find_smooth(const Face *face, const Face **smoothed) {
    (*smoothed) = NULL;

    if (face && face->smoothface) {
        (*smoothed) = face->smoothface;
        return 1;
    }

    return 0;
}

void free_all_images(void) {
    unsigned int i;

    for (i = 0; i < nrofpixmaps; i++)
        free((char*)(new_faces[i].name));
    free(new_faces);
}

static void check_faceset_fallback(int faceset, int togo) {
    int fallback = facesets[faceset].fallback;

    /* proper case - falls back to base set */
    if (fallback == 0)
        return;

    if (!facesets[fallback].prefix) {
        LOG(llevError, "Face set %d falls to non set faceset %d\n", faceset, fallback);
        abort();
    }
    togo--;
    if (togo == 0) {
        LOG(llevError, "Infinite loop found in facesets. aborting.\n");
        abort();
    }
    check_faceset_fallback(fallback, togo);
}

void read_client_images(void) {
    char filename[400];
    char buf[HUGE_BUF];
    char *cp, *cps[7+1], *slash;
    FILE *infile;
    int len, fileno, i;
    unsigned int num;
    const Face *face;

    memset(facesets, 0, sizeof(facesets));
    snprintf(filename, sizeof(filename), "%s/image_info", settings.datadir);
    if ((infile = fopen(filename, "r")) == NULL) {
        LOG(llevError, "Unable to open %s\n", filename);
        abort();
    }
    while (fgets(buf, HUGE_BUF-1, infile) != NULL) {
        if (buf[0] == '#')
            continue;
        if (split_string(buf, cps, sizeof(cps)/sizeof(*cps), ':') != 7)
            LOG(llevError, "Bad line in image_info file, ignoring line:\n  %s", buf);
        else {
            len = atoi(cps[0]);
            if (len >= MAX_FACE_SETS) {
                LOG(llevError, "To high a setnum in image_info file: %d > %d\n", len, MAX_FACE_SETS);
                abort();
            }
            facesets[len].prefix = strdup_local(cps[1]);
            facesets[len].fullname = strdup_local(cps[2]);
            facesets[len].fallback = atoi(cps[3]);
            facesets[len].size = strdup_local(cps[4]);
            facesets[len].extension = strdup_local(cps[5]);
            facesets[len].comment = strdup_local(cps[6]);
        }
    }
    fclose(infile);
    for (i = 0; i < MAX_FACE_SETS; i++) {
        if (facesets[i].prefix)
            check_faceset_fallback(i, MAX_FACE_SETS);
    }
    /* Loaded the faceset information - now need to load up the
     * actual faces.
     */

    for (fileno = 0; fileno < MAX_FACE_SETS; fileno++) {
        /* if prefix is not set, this is not used */
        if (!facesets[fileno].prefix)
            continue;
        facesets[fileno].faces = calloc(nrofpixmaps, sizeof(face_info));

        snprintf(filename, sizeof(filename), "%s/crossfire.%d", settings.datadir, fileno);
        LOG(llevDebug, "images: loading from %s\n", filename);

        if ((infile = fopen(filename, "rb")) == NULL) {
            LOG(llevError, "Unable to open %s\n", filename);
            abort();
        }
        while (fgets(buf, HUGE_BUF-1, infile) != NULL) {
            if (strncmp(buf, "IMAGE ", 6) != 0) {
                LOG(llevError, "read_client_images:Bad image line - not IMAGE, instead\n%s", buf);
                abort();
            }
            cp = buf + 6;
            len = atoi(cp);
            if (len == 0 || len > MAX_IMAGE_SIZE) {
                LOG(llevError, "read_client_images: length not valid: %d > %d \n%s", len, MAX_IMAGE_SIZE, buf);
                abort();
            }

            for ( ; *cp != ' ' && *cp != '\n' && *cp != '\0'; cp++) {
                /* Increment pointer until next token. */
            }

            if (*cp != ' ') {
                LOG(llevError, "read_client_images: couldn't read name\n");
                abort();
            }
            cp++;
            /* cp points to the start of the full name */
            slash = strrchr(cp, '/');
            if (slash != NULL)
                cp = slash + 1;
            if (cp[strlen(cp) - 1] == '\n')
                cp[strlen(cp) - 1] = '\0';

            /* cp points to the start of the picture name itself */
            face = find_face(cp, NULL);
            if (face == NULL) {
                LOG(llevError, "read_client_images: couldn't find picture %s\n", cp);
                abort();
            }
            num = face->number;
            if (num >= nrofpixmaps) {
                LOG(llevError, "read_client_images: invalid picture number %d for %s\n", num, cp);
                abort();
            }

            facesets[fileno].faces[num].datalen = len;
            facesets[fileno].faces[num].data = malloc(len);
            if ((i = fread(facesets[fileno].faces[num].data, len, 1, infile)) != 1) {
                LOG(llevError, "read_client_images: Did not read desired amount of data, wanted %d, got %d\n%s", len, i, buf);
                abort();
            }
            facesets[fileno].faces[num].checksum = 0;
            for (i = 0; i < len; i++) {
                ROTATE_RIGHT(facesets[fileno].faces[num].checksum);
                facesets[fileno].faces[num].checksum += facesets[fileno].faces[num].data[i];
                facesets[fileno].faces[num].checksum &= 0xffffffff;
            }
        }
        fclose(infile);
    } /* For fileno < MAX_FACE_SETS */
}

int is_valid_faceset(int fsn) {
    if (fsn >= 0 && fsn < MAX_FACE_SETS && facesets[fsn].prefix)
        return TRUE;
    return FALSE;
}

void free_socket_images(void) {
    int num;
    unsigned int q;

    for (num = 0; num < MAX_FACE_SETS; num++) {
        if (facesets[num].prefix) {
            for (q = 0; q < nrofpixmaps; q++)
                free(facesets[num].faces[q].data);
            free(facesets[num].prefix);
            free(facesets[num].fullname);
            free(facesets[num].size);
            free(facesets[num].extension);
            free(facesets[num].comment);
            free(facesets[num].faces);
        }
    }
}

int get_face_fallback(int faceset, int imageno) {
    /* faceset 0 is supposed to have every image, so just return.  Doing
     * so also prevents infinite loops in the case if it not having
     * the face, but in that case, we are likely to crash when we try
     * to access the data, but that is probably preferable to an infinite
     * loop.
     */
    if (faceset == 0)
        return 0;

    if (!facesets[faceset].prefix) {
        LOG(llevError, "get_face_fallback called with unused set (%d)?\n", faceset);
        return 0;   /* use default set */
    }
    if (facesets[faceset].faces[imageno].data)
        return faceset;
    return get_face_fallback(facesets[faceset].fallback, imageno);
}

unsigned int get_faces_count() {
    return nrofpixmaps;
}

const Face *get_face_by_index(int index) {
    if (index < 0 || index >= nrofpixmaps)
        return NULL;
    return &new_faces[index];
}

const Face *get_face_by_id(uint16_t id) {
    for (int f = 0; f < nrofpixmaps; f++) {
        if (new_faces[f].number == id)
            return &new_faces[f];
    }
    return NULL;
}