/* * CrossFire, A Multiplayer game for X-windows * * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team * Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team * Copyright (C) 1992 Frank Tore Johansen * * 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., 675 Mass Ave, Cambridge, MA 02139, USA. * * The authors can be reached via e-mail at */ #include #include region * region::default_region () { for (region *reg = first_region; reg; reg = reg->next) if (reg->fallback) return reg; return first_region; } /* * Pass a char array, returns a pointer to the region of the same name. * if it can't find a region of the same name it returns the first region * with the 'fallback' property set. * if it can't find a matching name /or/ a fallback region it logs an info message * message and returns NULL * used by the map parsing code. */ region * region::find (const char *name) { for (region *reg = first_region; reg; reg = reg->next) if (!strcmp (reg->name, name)) return reg; LOG (llevError, "region called %s requested, but not found, using fallback.\n", name); return default_region (); } /* * Tries to find a region that 'name' corresponds to. * It looks, in order, for: * an exact match to region name (case insensitive) * an exact match to longname (case insensitive) * a substring that matches to the longname (eg Kingdom) * a substring that matches to the region name (eg nav) * if it can find none of these it returns the first parentless region * (there should be only one of these - the top level one) * If we got a NULL, then just return the top level region * */ region * region::find_fuzzy (const char *name) { region *reg; char *substr; char *p; if (name == NULL) { for (reg = first_region; reg->parent; reg = reg->parent) ; return reg; } p = strchr (name, '\n'); if (p) *p = '\0'; for (reg = first_region; reg; reg = reg->next) if (!strcasecmp (reg->name, name)) return reg; for (reg = first_region; reg; reg = reg->next) if (reg->longname) if (!strcasecmp (reg->longname, name)) return reg; substr = NULL; for (reg = first_region; reg; reg = reg->next) if (reg->longname) { substr = strstr (reg->longname, name); if (substr) return reg; } for (reg = first_region; reg; reg = reg->next) if (reg->longname) { /* * 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) return reg; } for (reg = first_region; reg; reg = reg->next) { substr = strstr (reg->name, name); if (substr) return reg; } /* if we are still here, we are going to have to give up, and give the top level region */ for (reg = first_region; reg->parent; reg = reg->parent) ; return reg; } /* * returns 1 if the player is in the region reg, or a child region thereof * otherwise returns 0 * if passed a NULL region returns -1 */ static 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; } /** Returns an object which is an exit through which the player represented by op should be * sent in order to be imprisoned. If there is no suitable place to which an exit can be * constructed, then NULL will be returned. The caller is responsible for freeing the object * created by this function. */ object * get_jail_exit (object *op) { region *reg; object *exit; if (op->type != PLAYER) { LOG (llevError, "region.c: get_jail_exit called against non-player object.\n"); return NULL; } reg = op->region (); while (reg) { if (reg->jailmap) { exit = object::create (); EXIT_PATH (exit) = 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", ®->name); return NULL; } static void assign_region_parents (void) { region *reg; uint32 parent_count = 0; uint32 region_count = 0; for (reg = first_region; reg && reg->next; reg = reg->next) { if (reg->parent_name) { reg->parent = region::find (reg->parent_name); parent_count++; } region_count++; } LOG (llevDebug, "Assigned %u regions with %u parents.\n", region_count, parent_count); } /* * Reads/parses the region file, and copies into a linked list * of region structs. */ static bool parse_regions (object_thawer &fp) { region *newreg; region *reg; newreg = NULL; for (;;) { keyword kw = fp.get_kv (); switch (kw) { case KW_EOF: if (newreg) { LOG (llevError, "%s: end of file while reading regions.\n", fp.name); return false; } else return true; case KW_end: /* Place this new region last on the list, if the list is empty put it first */ for (reg = first_region; reg && reg->next; reg = reg->next) ; if (!reg) first_region = newreg; else reg->next = newreg; newreg = 0; break; default: case KW_ERROR: LOG (llevError, "%s: skipping errornous line (%s) while reading regions.\n", fp.name, fp.last_keyword); break; case KW_region: newreg = new region; fp.get (newreg->name); break; case KW_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. */ fp.get (newreg->parent_name); break; case KW_longname: newreg->longname = strdup (fp.get_str ()); break; case KW_jail_map: fp.get (newreg->jailmap); break; case KW_jail_x: fp.get (newreg->jailx); break; case KW_jail_y: fp.get (newreg->jaily); break; case KW_msg: fp.get_ml (KW_endmsg, newreg->msg); break; case KW_fallback: fp.get (newreg->fallback); break; case KW_nomore: /* we have reached the end of the region specs.... */ return true; } } } /* * First initialises the archtype hash-table (init_archetable()). * Reads and parses the archetype file (with the first and second-pass * functions). * Then initialises treasures by calling load_treasures(). */ void init_regions (void) { char filename[MAX_BUF]; int comp; if (first_region != NULL) /* Only do this once */ return; // make sure one region is always available first_region = new region; first_region->name = ""; first_region->longname = strdup ("Built-in Region"); sprintf (filename, "%s/%s/%s", settings.datadir, settings.mapdir, settings.regions); LOG (llevDebug, "Reading regions from %s...\n", filename); object_thawer fp (filename); if (!fp) { LOG (llevError, " Can't open regions file %s in init_regions.\n", filename); return; } parse_regions (fp); assign_region_parents (); LOG (llevDebug, " done\n"); }