region.cpp

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 <ctype.h>
#include <stdlib.h>
#include <string.h>
 
#ifndef WIN32 /* ---win32 exclude header */
#include <unistd.h>
#endif /* win32 */
 
#include <map>
 
region *get_region_by_name(const char *region_name) {
    for (auto reg : all_regions)
        if (!strcmp(reg->name, region_name))
            return reg;
 
    for (auto reg : all_regions) {
        if (reg->fallback) {
            LOG(llevDebug, "region called %s requested, but not found, fallback used.\n", region_name);
            return reg;
        }
    }
    LOG(llevInfo, "Got no region or fallback for region %s.\n", region_name);
    return NULL;
}
 
region *get_region_by_map(mapstruct *m) {
    return get_region_by_name(get_name_of_region_for_map(m));
}
 
const char *get_name_of_region_for_map(const mapstruct  *m) {
    if (m->region != NULL)
        return m->region->name;
    for (auto reg : all_regions) {
        if (reg->fallback)
            return reg->name;
    }
    LOG(llevInfo, "map %s had no region and I couldn't find a fallback to use.\n", m->name);
    return "unknown";
}
 
region *get_region_from_string(const char *name) {
    region *reg;
    char *substr;
 
    if (all_regions.empty()) {
        return NULL;
    }
 
    if (*name == '\0') {
        for (reg = all_regions.front(); reg->parent != NULL; reg = reg->parent)
            ;
        return reg;
    }
 
    for (auto reg : all_regions)
        if (!strcasecmp(reg->name, name))
            return reg;
 
    for (auto reg : all_regions)
        if (reg->longname != NULL) {
            if (!strcasecmp(reg->longname, name))
                return reg;
        }
 
    substr = NULL;
    for (auto reg : all_regions)
        if (reg->longname != NULL) {
            substr = strstr(reg->longname, name);
            if (substr != NULL)
                return reg;
        }
    for (auto reg : all_regions)
        if (reg->longname != NULL) {
            /*
             * This is not a bug, we want the region that is  most identifiably a discrete
             * area in the game, eg if we have 'scor', we want to return 'scorn' and not
             * 'scornarena', regardless of their order on the list so we only look at those
             * regions with a longname set.
             */
            substr = strstr(reg->name, name);
            if (substr != NULL)
                return reg;
        }
    for (auto reg : all_regions) {
        substr = strstr(reg->name, name);
        if (substr != NULL)
            return reg;
    }
    /* if we are still here, we are going to have to give up, and give the top level region */
    for (reg = all_regions.front(); reg->parent != NULL; reg = reg->parent)
        ;
    return reg;
}
 
int region_is_child_of_region(const region *child, const region *r) {
    if (r == NULL)
        return -1;
    if (child == NULL)
        return 0;
    if (!strcmp(child->name, r->name))
        return 1;
    else if (child->parent != NULL)
        return region_is_child_of_region(child->parent, r);
    else
        return 0;
}
 
const char *get_region_longname(const region *r) {
    if (r->longname != NULL)
        return r->longname;
    else if (r->parent != NULL)
        return get_region_longname(r->parent);
    else {
        LOG(llevDebug, "NOTICE region %s has no parent and no longname.\n", r->name);
        return "no name can be found for the current region";
    }
}
 
const char *get_region_msg(const region *r) {
    if (r->msg != NULL)
        return r->msg;
    else if (r->parent != NULL)
        return get_region_msg(r->parent);
    else {
        LOG(llevDebug, "NOTICE region %s has no parent and no msg.\n", r->name);
        return "no description can be found for the current region";
    }
}
 
object *get_jail_exit(object *op) {
    region *reg, *orig;
    object *exit;
 
    if (op->type != PLAYER) {
        LOG(llevError, "region.c: get_jail_exit called against non-player object.\n");
        return NULL;
    }
 
    reg = get_region_by_map(op->map);
    orig = reg;
    while (reg != NULL) {
        if (reg->jailmap) {
            exit = object_new();
            EXIT_PATH(exit) = add_string(reg->jailmap);
            /* damned exits reset savebed and remove teleports, so the prisoner can't escape */
            SET_FLAG(exit, FLAG_DAMNED);
            EXIT_X(exit) = reg->jailx;
            EXIT_Y(exit) = reg->jaily;
            return exit;
        } else
            reg = reg->parent;
    }
    LOG(llevDebug, "No suitable jailmap for region %s was found.\n", orig ? orig->name : "(unknown region?)");
    return NULL;
}
 
region *get_region_struct(void) {
    region *add = (region *)calloc(1, sizeof(region));
    if (add == NULL)
        fatal(OUT_OF_MEMORY);
 
    return add;
}
 
void init_regions(BufferReader *reader, const char *filename) {
    region *add;
    char *buf;
 
    char msgbuf[HUGE_BUF], *value;
    int msgpos = 0;
 
    if (!all_regions.empty()) /* Only do this once */
        return;
 
    std::map<region *, std::string> parents;
 
    add = NULL;
    while ((buf = bufferreader_next_line(reader)) != NULL) {
        while (isspace(*buf))
            buf++;
        if (*buf == 0)
            continue;    /* empty line */
        value = strchr(buf, ' ');
        if (value) {
            *value = 0;
            value++;
            while (isspace(*value))
                value++;
        }
 
        /*
         * This is a bizzare mutated form of the map and archetype parser
         * rolled into one. Key is the field name, value is what it should
         * be set to.
         * We've already done the work to null terminate key,
         * and strip off any leading spaces for both of these.
         * We have not touched the newline at the end of the line -
         * these might be needed for some values. the end pointer
         * points to the first of the newlines.
         * value could be NULL!  It would be easy enough to just point
         * this to "" to prevent cores, but that would let more errors slide
         * through.
         */
        if (!strcmp(buf, "region")) {
            add = get_region_struct();
            add->name = strdup_local(value);
        } else if (!strcmp(buf, "parent")) {
            /*
             * Note that this is in the initialisation code, so we don't actually
             * assign the pointer to the parent yet, because it might not have been
             * parsed.
             */
 
            if (!add) {
                LOG(llevError, "region.c: malformated regions file: \"parent\" before \"region\".\n");
                fatal(SEE_LAST_ERROR);
            }
            if (!value) {
                LOG(llevError, "region.c: malformated regions file: No value given for \"parent\" key.\n");
                fatal(SEE_LAST_ERROR);
            }
            parents[add] = value;
        } else if (!strcmp(buf, "longname")) {
            if (!add) {
                LOG(llevError, "region.c: malformated regions file: \"longname\" before \"region\".\n");
                fatal(SEE_LAST_ERROR);
            }
            if (!value) {
                LOG(llevError, "region.c: malformated regions file: No value given for \"longname\" key.\n");
                fatal(SEE_LAST_ERROR);
            }
            add->longname = strdup_local(value);
        } else if (!strcmp(buf, "jail")) {
            /* jail entries are of the form: /path/to/map x y */
            char path[MAX_BUF];
            int x, y;
 
            if (!add) {
                LOG(llevError, "region.c: malformated regions file: \"jail\" before \"region\".\n");
                fatal(SEE_LAST_ERROR);
            }
            if (!value) {
                LOG(llevError, "region.c: malformated regions file: No value given for \"jail\" key.\n");
                fatal(SEE_LAST_ERROR);
            }
 
            if (sscanf(value, "%[^ ] %d %d\n", path, &x, &y) != 3) {
                LOG(llevError, "region.c: malformated regions entry: jail %s\n", value);
                continue;
            }
            add->jailmap = strdup_local(path);
            add->jailx = x;
            add->jaily = y;
        } else if (!strcmp(buf, "msg")) {
            if (!add) {
                LOG(llevError, "region.c: malformated regions file: \"msg\" before \"region\".\n");
                fatal(SEE_LAST_ERROR);
            }
            char *other;
            while ((other = bufferreader_next_line(reader)) != NULL) {
                while (isspace(*other))
                    other++;
                if (strcmp(other, "endmsg") == 0)
                    break;
                else {
                    strcpy(msgbuf+msgpos, other);
                    msgpos += strlen(other);
                    strcpy(msgbuf+msgpos, "\n");
                    ++msgpos;
                }
            }
            /*
             * There may be regions with empty messages (eg, msg/endmsg
             * with nothing between). When maps are loaded, this is done
             * so better do it here too...
             */
            if (msgpos != 0)
                add->msg = strdup_local(msgbuf);
 
            /* we have to reset msgpos, or the next region will store both msg blocks.*/
            msgpos = 0;
        } else if (!strcmp(buf, "fallback")) {
            if (!add) {
                LOG(llevError, "region.c: malformated regions file %s: \"fallback\" before \"region\".\n", filename);
                fatal(SEE_LAST_ERROR);
            }
            if (!value) {
                LOG(llevError, "region.c: malformated regions file %s: No value given for \"fallback\" key.\n", filename);
                fatal(SEE_LAST_ERROR);
            }
            add->fallback = atoi(value);
        } else if (!strcmp(buf, "end")) {
            if (!add) {
                LOG(llevError, "region.c: Ignoring spurious \"end\" between regions.\n");
                continue;
            }
            all_regions.push_back(add);
            add = NULL;
        } else if (!strcmp(buf, "nomore")) {
            if (add) {
                LOG(llevError, "region.c: Last region not properly closed.\n");
                free(add);
            }
            /* we have reached the end of the region specs....*/
            break;
        } else {
            /* we should never get here, if we have, then something is wrong */
            LOG(llevError, "Got unknown value in region file %s: %s %s\n", filename, buf, value);
        }
    }
    if (!buf || strcmp(buf, "nomore")) {
        LOG(llevError, "Got premature eof on regions file %s!\n", filename);
        free(add);
    }
 
    for (auto p : parents) {
        p.first->parent = get_region_by_name(p.second.c_str());
        if (!p.first->parent) {
            LOG(llevError, "Couldn't find parent %s for region %s\n", p.second.c_str(), p.first->name);
        }
    }
}