server/common/region.C


/*
 * static char *rcsid_map_c =
 *   "$Id: region.C,v 1.3 2006-09-03 00:18:40 root Exp $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    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 crossfire-devel@real-time.com
*/


#include <global.h>

#ifndef WIN32                   /* ---win32 exclude header */
# include <unistd.h>
#endif /* win32 */

/* 
 * 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 *
get_region_by_name (const char *region_name)
{
  region *reg;
  char *p = strchr (region_name, '\n');

  if (p)
    *p = '\0';
  for (reg = first_region; reg != NULL; reg = reg->next)
    if (!strcmp (reg->name, region_name))
      return reg;

  for (reg = first_region; reg != NULL; reg = reg->next)
    {
      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;
}

/* This might need optimising at some point. */
region *
get_region_by_map (mapstruct *m)
{
  return get_region_by_name (get_name_of_region_for_map (m));
}

/*
 * Since we won't assume all maps have a region set properly, we need an
 * explicit check that it is, this is much nicer here than scattered throughout
 * the map code.
 */

const char *
get_name_of_region_for_map (const mapstruct *m)
{
  region *reg;

  if (m->region != NULL)
    return m->region->name;
  for (reg = first_region; reg != NULL; reg = reg->next)
    {
      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";
}

/*
 * 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 *
get_region_from_string (const char *name)
{
  region *reg;
  char *substr;
  char *p;

  if (name == NULL)
    {
      for (reg = first_region; reg->parent != NULL; reg = reg->parent);
      return reg;
    }
  p = strchr (name, '\n');
  if (p)
    *p = '\0';
  for (reg = first_region; reg != NULL; reg = reg->next)
    if (!strcasecmp (reg->name, name))
      return reg;

  for (reg = first_region; reg != NULL; reg = reg->next)
    if (reg->longname != NULL)
      {
        if (!strcasecmp (reg->longname, name))
          return reg;
      }

  substr = NULL;
  for (reg = first_region; reg != NULL; reg = reg->next)
    if (reg->longname != NULL)
      {
        substr = strstr (reg->longname, name);
        if (substr != NULL)
          return reg;
      }
  for (reg = first_region; reg != NULL; reg = reg->next)
    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 (reg = first_region; reg != NULL; reg = reg->next)
    {
      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 = first_region; reg->parent != NULL; 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
 */

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;
}

/* 
 * the longname of a region is not a required field, any given region
 * may want to not set it and use the parent's one instead. so, we:
 * 1. check if a longname is set and if so return it.
 * 2. check if there is a parent and try and call the function against that
 * 3. return a obviously wrong string if we can't get a longname, this should
 *    never happen. We also log a debug message.
 */
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";
    }
}

/** 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 = get_region_by_map (op->map);
  while (reg != NULL)
    {
      if (reg->jailmap)
        {
          exit = get_object ();
          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", reg->name);
  return NULL;
}

/*
 * 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)
{
  FILE *fp;
  char filename[MAX_BUF];
  int comp;

  if (first_region != NULL)     /* Only do this once */
    return;

  sprintf (filename, "%s/%s/%s", settings.datadir, settings.mapdir, settings.regions);
  LOG (llevDebug, "Reading regions from %s...\n", filename);
  if ((fp = open_and_uncompress (filename, 0, &comp)) == NULL)
    {
      LOG (llevError, " Can't open regions file %s in init_regions.\n", filename);
      return;
    }
  parse_regions (fp);
  assign_region_parents ();
  LOG (llevDebug, " done\n");

  close_and_delete (fp, comp);
}

/* 
 * Allocates and zeros a region struct, this isn't free()'d anywhere, so might
 * be a memory leak, but it shouldn't matter too much since it isn't called that
 * often.... 
 */

region *
get_region_struct (void)
{

  region *reg;

  reg = (region *) CALLOC (1, sizeof (region));
  if (reg == NULL)
    fatal (OUT_OF_MEMORY);

  memset (reg, '\0', sizeof (region));

  return reg;
}

/*
 * Reads/parses the region file, and copies into a linked list
 * of region structs.
 */
void
parse_regions (FILE * fp)
{
  region *newreg;
  region *reg;

  char buf[HUGE_BUF], msgbuf[HUGE_BUF], *key = NULL, *value, *end;
  int msgpos = 0;

  newreg = NULL;
  while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
    {
      buf[HUGE_BUF - 1] = 0;
      key = buf;
      while (isspace (*key))
        key++;
      if (*key == 0)
        continue;               /* empty line */
      value = strchr (key, ' ');
      if (!value)
        {
          end = strchr (key, '\n');
          *end = 0;
        }
      else
        {
          *value = 0;
          value++;
          while (isspace (*value))
            value++;
          end = strchr (value, '\n');
        }

      /* 
       * 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 (key, "region"))
        {
          *end = 0;
          newreg = get_region_struct ();
          newreg->name = strdup_local (value);
        }
      else if (!strcmp (key, "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.
           */
          *end = 0;
          newreg->parent_name = strdup_local (value);
        }
      else if (!strcmp (key, "longname"))
        {
          *end = 0;
          newreg->longname = strdup_local (value);
        }
      else if (!strcmp (key, "jail"))
        {
          /* jail entries are of the form: /path/to/map x y */
          char path[MAX_BUF];
          int x, y;

          if (sscanf (value, "%[^ ] %d %d\n", path, &x, &y) != 3)
            {
              LOG (llevError, "region.c: malformated regions entry: jail %s\n", value);
              continue;
            }
          newreg->jailmap = strdup_local (path);
          newreg->jailx = x;
          newreg->jaily = y;
        }
      else if (!strcmp (key, "msg"))
        {
          while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
            {
              if (!strcmp (buf, "endmsg\n"))
                break;
              else
                {
                  strcpy (msgbuf + msgpos, buf);
                  msgpos += strlen (buf);
                }
            }
          /* 
           * 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)
            newreg->msg = strdup_local (msgbuf);

          /* we have to reset msgpos, or the next region will store both msg blocks. */
          msgpos = 0;
        }
      else if (!strcmp (key, "fallback"))
        {
          *end = 0;
          newreg->fallback = atoi (value);
        }
      else if (!strcmp (key, "end"))
        {
          /* Place this new region last on the list, if the list is empty put it first */
          for (reg = first_region; reg != NULL && reg->next != NULL; reg = reg->next);

          if (reg == NULL)
            first_region = newreg;
          else
            reg->next = newreg;
          newreg = NULL;
        }
      else if (!strcmp (key, "nomore"))
        {
          /* 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\n", key, value);
        }
    }
  if (!key || strcmp (key, "nomore"))
    LOG (llevError, "Got premature eof on regions file!\n");
}

void
assign_region_parents (void)
{
  region *reg;
  uint32 parent_count = 0;
  uint32 region_count = 0;

  for (reg = first_region; reg != NULL && reg->next != NULL; reg = reg->next)
    {
      if (reg->parent_name != NULL)
        {
          reg->parent = get_region_by_name (reg->parent_name);
          parent_count++;
        }
      region_count++;
    }
  LOG (llevDebug, "Assigned %u regions with %u parents.", region_count, parent_count);
}
Revision:	1.4
Committed:	Sun Sep 10 16:00:23 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+333 -252 lines
Log Message:	indent
#	User	Rev	Content
1	root	1.4
2	elmex	1.1	/*
3			* static char *rcsid_map_c =
4	root	1.4	* "$Id: region.C,v 1.3 2006-09-03 00:18:40 root Exp $";
5	elmex	1.1	*/
6
7			/*
8			CrossFire, A Multiplayer game for X-windows
9
10			Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
11			Copyright (C) 1992 Frank Tore Johansen
12
13			This program is free software; you can redistribute it and/or modify
14			it under the terms of the GNU General Public License as published by
15			the Free Software Foundation; either version 2 of the License, or
16			(at your option) any later version.
17
18			This program is distributed in the hope that it will be useful,
19			but WITHOUT ANY WARRANTY; without even the implied warranty of
20			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21			GNU General Public License for more details.
22
23			You should have received a copy of the GNU General Public License
24			along with this program; if not, write to the Free Software
25			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27			The authors can be reached via e-mail at crossfire-devel@real-time.com
28			*/
29
30
31			#include <global.h>
32
33	root	1.4	#ifndef WIN32 /* ---win32 exclude header */
34			# include <unistd.h>
35	elmex	1.1	#endif /* win32 */
36	root	1.4
37	elmex	1.1	/*
38			* Pass a char array, returns a pointer to the region of the same name.
39			* if it can't find a region of the same name it returns the first region
40			* with the 'fallback' property set.
41			* if it can't find a matching name /or/ a fallback region it logs an info message
42			* message and returns NULL
43			* used by the map parsing code.
44			*/
45	root	1.4	region *
46			get_region_by_name (const char *region_name)
47			{
48			region *reg;
49			char *p = strchr (region_name, '\n');
50
51			if (p)
52			*p = '\0';
53			for (reg = first_region; reg != NULL; reg = reg->next)
54			if (!strcmp (reg->name, region_name))
55			return reg;
56
57			for (reg = first_region; reg != NULL; reg = reg->next)
58			{
59			if (reg->fallback)
60			{
61			LOG (llevDebug, "region called %s requested, but not found, fallback used.\n", region_name);
62			return reg;
63	root	1.2	}
64	elmex	1.1	}
65	root	1.4	LOG (llevInfo, "Got no region or fallback for region %s.\n", region_name);
66			return NULL;
67	elmex	1.1	}
68
69			/* This might need optimising at some point. */
70	root	1.4	region *
71			get_region_by_map (mapstruct *m)
72			{
73			return get_region_by_name (get_name_of_region_for_map (m));
74	elmex	1.1	}
75
76			/*
77			* Since we won't assume all maps have a region set properly, we need an
78			* explicit check that it is, this is much nicer here than scattered throughout
79			* the map code.
80			*/
81
82	root	1.4	const char *
83			get_name_of_region_for_map (const mapstruct *m)
84			{
85			region *reg;
86
87			if (m->region != NULL)
88			return m->region->name;
89			for (reg = first_region; reg != NULL; reg = reg->next)
90			{
91			if (reg->fallback)
92			return reg->name;
93			}
94			LOG (llevInfo, "map %s had no region and I couldn't find a fallback to use.\n", m->name);
95			return "unknown";
96	elmex	1.1	}
97
98			/*
99			* Tries to find a region that 'name' corresponds to.
100			* It looks, in order, for:
101			* an exact match to region name (case insensitive)
102			* an exact match to longname (case insensitive)
103			* a substring that matches to the longname (eg Kingdom)
104			* a substring that matches to the region name (eg nav)
105			* if it can find none of these it returns the first parentless region
106			* (there should be only one of these - the top level one)
107			* If we got a NULL, then just return the top level region
108			*
109			*/
110	root	1.4	region *
111			get_region_from_string (const char *name)
112			{
113			region *reg;
114			char *substr;
115			char *p;
116
117			if (name == NULL)
118			{
119			for (reg = first_region; reg->parent != NULL; reg = reg->parent);
120			return reg;
121			}
122			p = strchr (name, '\n');
123			if (p)
124			*p = '\0';
125			for (reg = first_region; reg != NULL; reg = reg->next)
126			if (!strcasecmp (reg->name, name))
127			return reg;
128
129			for (reg = first_region; reg != NULL; reg = reg->next)
130			if (reg->longname != NULL)
131			{
132			if (!strcasecmp (reg->longname, name))
133			return reg;
134			}
135
136			substr = NULL;
137			for (reg = first_region; reg != NULL; reg = reg->next)
138			if (reg->longname != NULL)
139			{
140			substr = strstr (reg->longname, name);
141			if (substr != NULL)
142			return reg;
143			}
144			for (reg = first_region; reg != NULL; reg = reg->next)
145			if (reg->longname != NULL)
146			{
147	root	1.2	/*
148			* This is not a bug, we want the region that is most identifiably a discrete
149			* area in the game, eg if we have 'scor', we want to return 'scorn' and not
150			* 'scornarena', regardless of their order on the list so we only look at those
151			* regions with a longname set.
152			*/
153	root	1.4	substr = strstr (reg->name, name);
154			if (substr != NULL)
155			return reg;
156			}
157			for (reg = first_region; reg != NULL; reg = reg->next)
158			{
159			substr = strstr (reg->name, name);
160			if (substr != NULL)
161			return reg;
162			}
163			/* if we are still here, we are going to have to give up, and give the top level region */
164			for (reg = first_region; reg->parent != NULL; reg = reg->parent);
165			return reg;
166	elmex	1.1	}
167
168			/*
169			* returns 1 if the player is in the region reg, or a child region thereof
170			* otherwise returns 0
171			* if passed a NULL region returns -1
172			*/
173
174	root	1.4	int
175			region_is_child_of_region (const region * child, const region * r)
176			{
177
178			if (r == NULL)
179			return -1;
180			if (child == NULL)
181			return 0;
182			if (!strcmp (child->name, r->name))
183			return 1;
184			else if (child->parent != NULL)
185			return region_is_child_of_region (child->parent, r);
186			else
187			return 0;
188	elmex	1.1	}
189
190			/*
191			* the longname of a region is not a required field, any given region
192			* may want to not set it and use the parent's one instead. so, we:
193			* 1. check if a longname is set and if so return it.
194			* 2. check if there is a parent and try and call the function against that
195			* 3. return a obviously wrong string if we can't get a longname, this should
196			* never happen. We also log a debug message.
197			*/
198	root	1.4	const char *
199			get_region_longname (const region * r)
200			{
201
202			if (r->longname != NULL)
203			return r->longname;
204			else if (r->parent != NULL)
205			return get_region_longname (r->parent);
206			else
207			{
208			LOG (llevDebug, "NOTICE region %s has no parent and no longname.\n", r->name);
209			return "no name can be found for the current region";
210	elmex	1.1	}
211			}
212
213	root	1.4	const char *
214			get_region_msg (const region * r)
215			{
216			if (r->msg != NULL)
217			return r->msg;
218			else if (r->parent != NULL)
219			return get_region_msg (r->parent);
220			else
221			{
222			LOG (llevDebug, "NOTICE region %s has no parent and no msg.\n", r->name);
223			return "no description can be found for the current region";
224	elmex	1.1	}
225			}
226
227			/** Returns an object which is an exit through which the player represented by op should be
228			* sent in order to be imprisoned. If there is no suitable place to which an exit can be
229			* constructed, then NULL will be returned. The caller is responsible for freeing the object
230			* created by this function.
231			*/
232	root	1.4	object *
233			get_jail_exit (object *op)
234			{
235			region *reg;
236			object *exit;
237
238			if (op->type != PLAYER)
239			{
240			LOG (llevError, "region.c: get_jail_exit called against non-player object.\n");
241			return NULL;
242			}
243			reg = get_region_by_map (op->map);
244			while (reg != NULL)
245			{
246			if (reg->jailmap)
247			{
248			exit = get_object ();
249			EXIT_PATH (exit) = reg->jailmap;
250			/* damned exits reset savebed and remove teleports, so the prisoner can't escape */
251			SET_FLAG (exit, FLAG_DAMNED);
252			EXIT_X (exit) = reg->jailx;
253			EXIT_Y (exit) = reg->jaily;
254			return exit;
255	root	1.2	}
256	root	1.4	else
257			reg = reg->parent;
258	elmex	1.1	}
259	root	1.4	LOG (llevDebug, "No suitable jailmap for region %s was found.\n", reg->name);
260			return NULL;
261	elmex	1.1	}
262
263			/*
264			* First initialises the archtype hash-table (init_archetable()).
265			* Reads and parses the archetype file (with the first and second-pass
266			* functions).
267			* Then initialises treasures by calling load_treasures().
268			*/
269	root	1.4	void
270			init_regions (void)
271			{
272			FILE *fp;
273			char filename[MAX_BUF];
274			int comp;
275
276			if (first_region != NULL) /* Only do this once */
277	elmex	1.1	return;
278
279	root	1.4	sprintf (filename, "%s/%s/%s", settings.datadir, settings.mapdir, settings.regions);
280			LOG (llevDebug, "Reading regions from %s...\n", filename);
281			if ((fp = open_and_uncompress (filename, 0, &comp)) == NULL)
282			{
283			LOG (llevError, " Can't open regions file %s in init_regions.\n", filename);
284			return;
285			}
286			parse_regions (fp);
287			assign_region_parents ();
288			LOG (llevDebug, " done\n");
289
290			close_and_delete (fp, comp);
291	elmex	1.1	}
292
293			/*
294			* Allocates and zeros a region struct, this isn't free()'d anywhere, so might
295			* be a memory leak, but it shouldn't matter too much since it isn't called that
296			* often....
297			*/
298
299	root	1.4	region *
300			get_region_struct (void)
301			{
302
303			region *reg;
304	elmex	1.1
305	root	1.4	reg = (region *) CALLOC (1, sizeof (region));
306			if (reg == NULL)
307			fatal (OUT_OF_MEMORY);
308	elmex	1.1
309	root	1.4	memset (reg, '\0', sizeof (region));
310	elmex	1.1
311	root	1.4	return reg;
312	elmex	1.1	}
313
314			/*
315			* Reads/parses the region file, and copies into a linked list
316			* of region structs.
317			*/
318	root	1.4	void
319			parse_regions (FILE * fp)
320			{
321			region *newreg;
322			region *reg;
323
324			char buf[HUGE_BUF], msgbuf[HUGE_BUF], key = NULL, value, *end;
325			int msgpos = 0;
326
327			newreg = NULL;
328			while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
329			{
330			buf[HUGE_BUF - 1] = 0;
331			key = buf;
332			while (isspace (*key))
333			key++;
334			if (*key == 0)
335			continue; /* empty line */
336			value = strchr (key, ' ');
337			if (!value)
338			{
339			end = strchr (key, '\n');
340			*end = 0;
341			}
342			else
343			{
344			*value = 0;
345			value++;
346			while (isspace (*value))
347	root	1.2	value++;
348	root	1.4	end = strchr (value, '\n');
349	root	1.2	}
350	root	1.4
351			/*
352			* This is a bizzare mutated form of the map and archetype parser
353			* rolled into one. Key is the field name, value is what it should
354			* be set to.
355			* We've already done the work to null terminate key,
356			* and strip off any leading spaces for both of these.
357			* We have not touched the newline at the end of the line -
358			* these might be needed for some values. the end pointer
359			* points to the first of the newlines.
360			* value could be NULL! It would be easy enough to just point
361			* this to "" to prevent cores, but that would let more errors slide
362			* through.
363			*/
364			if (!strcmp (key, "region"))
365			{
366			*end = 0;
367			newreg = get_region_struct ();
368			newreg->name = strdup_local (value);
369			}
370			else if (!strcmp (key, "parent"))
371			{
372			/*
373			* Note that this is in the initialisation code, so we don't actually
374			* assign the pointer to the parent yet, because it might not have been
375			* parsed.
376			*/
377			*end = 0;
378			newreg->parent_name = strdup_local (value);
379			}
380			else if (!strcmp (key, "longname"))
381			{
382			*end = 0;
383			newreg->longname = strdup_local (value);
384			}
385			else if (!strcmp (key, "jail"))
386			{
387			/* jail entries are of the form: /path/to/map x y */
388			char path[MAX_BUF];
389			int x, y;
390
391			if (sscanf (value, "%[^ ] %d %d\n", path, &x, &y) != 3)
392			{
393			LOG (llevError, "region.c: malformated regions entry: jail %s\n", value);
394			continue;
395	root	1.2	}
396	root	1.4	newreg->jailmap = strdup_local (path);
397			newreg->jailx = x;
398			newreg->jaily = y;
399			}
400			else if (!strcmp (key, "msg"))
401			{
402			while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
403			{
404			if (!strcmp (buf, "endmsg\n"))
405			break;
406			else
407			{
408			strcpy (msgbuf + msgpos, buf);
409			msgpos += strlen (buf);
410	root	1.2	}
411			}
412	root	1.4	/*
413			* There may be regions with empty messages (eg, msg/endmsg
414			* with nothing between). When maps are loaded, this is done
415			* so better do it here too...
416			*/
417			if (msgpos != 0)
418			newreg->msg = strdup_local (msgbuf);
419
420			/* we have to reset msgpos, or the next region will store both msg blocks. */
421			msgpos = 0;
422			}
423			else if (!strcmp (key, "fallback"))
424			{
425			*end = 0;
426			newreg->fallback = atoi (value);
427			}
428			else if (!strcmp (key, "end"))
429			{
430			/* Place this new region last on the list, if the list is empty put it first */
431			for (reg = first_region; reg != NULL && reg->next != NULL; reg = reg->next);
432
433			if (reg == NULL)
434			first_region = newreg;
435			else
436			reg->next = newreg;
437			newreg = NULL;
438			}
439			else if (!strcmp (key, "nomore"))
440			{
441			/* we have reached the end of the region specs.... */
442			break;
443			}
444			else
445			{
446			/* we should never get here, if we have, then something is wrong */
447			LOG (llevError, "Got unknown value in region file: %s %s\n", key, value);
448			}
449			}
450			if (!key \|\| strcmp (key, "nomore"))
451			LOG (llevError, "Got premature eof on regions file!\n");
452			}
453
454			void
455			assign_region_parents (void)
456			{
457			region *reg;
458			uint32 parent_count = 0;
459			uint32 region_count = 0;
460
461			for (reg = first_region; reg != NULL && reg->next != NULL; reg = reg->next)
462			{
463			if (reg->parent_name != NULL)
464			{
465			reg->parent = get_region_by_name (reg->parent_name);
466			parent_count++;
467	root	1.2	}
468	root	1.4	region_count++;
469	elmex	1.1	}
470	root	1.4	LOG (llevDebug, "Assigned %u regions with %u parents.", region_count, parent_count);
471	elmex	1.1	}