server/common/region.C

/*
 * 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 <crossfire@schmorp.de>
 */

#include <global.h>
#include <unistd.h>

#include "loader.h"

regionvec regions;

region *
region::default_region ()
{
  for_all_regions (rgn)
    if (rgn->fallback)
      return rgn;

  return regions [0];
}

/* 
 * 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_all_regions (rgn)
    if (!strcmp (rgn->name, name))
      return rgn;

  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)
{
  if (!name)
    return default_region ();

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

  for_all_regions (rgn)
    if (!strcasecmp (rgn->name, name))
      return rgn;

  for_all_regions (rgn)
    if (rgn->longname)
      if (!strcasecmp (rgn->longname, name))
        return rgn;

  for_all_regions (rgn)
    if (rgn->longname)
      {
        if (strstr (rgn->longname, name))
          return rgn;
      }

  for_all_regions (rgn)
    if (rgn->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.
         */
        if (strstr (rgn->name, name))
          return rgn;
      }

  for_all_regions (rgn)
    {
      if (strstr (rgn->name, name))
        return rgn;
    }

  return default_region ();
}

/* 
 * 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 (llevError, "No suitable jailmap for region %s was found.\n", &reg->name);

  return 0;
}

region *
region::load (object_f &f)
{
  region *rgn = new region;
  f.get (rgn->name);
  f.next_kv ();

  for (;;)
    {
      switch (f.kw)
        {
          case KW_parent:
            rgn->parent = region::find (f.get_str ());
            break;

          case KW_longname:
            f.get (rgn->longname);
            break;

          case KW_jail_map:
            f.get (rgn->jailmap);
            break;

          case KW_jail_x:
            f.get (rgn->jailx);
            break;

          case KW_jail_y:
            f.get (rgn->jaily);
            break;

          case KW_msg:
            f.get_ml (KW_endmsg, rgn->msg);
            break;

          case KW_fallback:
            f.get (rgn->fallback);
            break;

          case KW_end:
            for_all_regions (old)
              if (old->name == rgn->name)
                {
                  // replace, copy new values (ugly)
                  rgn->index = old->index;
                  *old = *rgn;
                  delete rgn;

                  return old;
                }

            // just append
            regions.push_back (rgn);
            return rgn;

          default:
            if (!f.parse_error ("region", rgn->name))
              {
                delete rgn;
                return 0;
              }
            break;
        }

      f.next_kv ();
    }
}

/*
 * 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)
{
  if (!regions.size ())
    {
      // make sure one region is always available
      region *rgn = new region;
      rgn->name = "<builtin>";
      rgn->longname = "Built-in Region";
      regions.push_back (rgn);
    }
}

Revision:	1.25
Committed:	Thu Feb 15 21:07:48 2007 UTC (17 years, 3 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.24:	+37 -41 lines
Log Message:	- use a simpler, less fancy loader base design (basically a one-line-lookahead top-down parser).
#	Content
1	/*
2	* CrossFire, A Multiplayer game for X-windows
3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5	* Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>
23	*/
24
25	#include <global.h>
26	#include <unistd.h>
27
28	#include "loader.h"
29
30	regionvec regions;
31
32	region *
33	region::default_region ()
34	{
35	for_all_regions (rgn)
36	if (rgn->fallback)
37	return rgn;
38
39	return regions [0];
40	}
41
42	/*
43	* Pass a char array, returns a pointer to the region of the same name.
44	* if it can't find a region of the same name it returns the first region
45	* with the 'fallback' property set.
46	* if it can't find a matching name /or/ a fallback region it logs an info message
47	* message and returns NULL
48	* used by the map parsing code.
49	*/
50	region *
51	region::find (const char *name)
52	{
53	for_all_regions (rgn)
54	if (!strcmp (rgn->name, name))
55	return rgn;
56
57	LOG (llevError, "region called %s requested, but not found, using fallback.\n", name);
58
59	return default_region ();
60	}
61
62	/*
63	* Tries to find a region that 'name' corresponds to.
64	* It looks, in order, for:
65	* an exact match to region name (case insensitive)
66	* an exact match to longname (case insensitive)
67	* a substring that matches to the longname (eg Kingdom)
68	* a substring that matches to the region name (eg nav)
69	* if it can find none of these it returns the first parentless region
70	* (there should be only one of these - the top level one)
71	* If we got a NULL, then just return the top level region
72	*
73	*/
74	region *
75	region::find_fuzzy (const char *name)
76	{
77	if (!name)
78	return default_region ();
79
80	char *p = strchr (name, '\n');
81	if (p)
82	*p = '\0';
83
84	for_all_regions (rgn)
85	if (!strcasecmp (rgn->name, name))
86	return rgn;
87
88	for_all_regions (rgn)
89	if (rgn->longname)
90	if (!strcasecmp (rgn->longname, name))
91	return rgn;
92
93	for_all_regions (rgn)
94	if (rgn->longname)
95	{
96	if (strstr (rgn->longname, name))
97	return rgn;
98	}
99
100	for_all_regions (rgn)
101	if (rgn->longname)
102	{
103	/*
104	* This is not a bug, we want the region that is most identifiably a discrete
105	* area in the game, eg if we have 'scor', we want to return 'scorn' and not
106	* 'scornarena', regardless of their order on the list so we only look at those
107	* regions with a longname set.
108	*/
109	if (strstr (rgn->name, name))
110	return rgn;
111	}
112
113	for_all_regions (rgn)
114	{
115	if (strstr (rgn->name, name))
116	return rgn;
117	}
118
119	return default_region ();
120	}
121
122	/*
123	* returns 1 if the player is in the region reg, or a child region thereof
124	* otherwise returns 0
125	* if passed a NULL region returns -1
126	*/
127
128	static int
129	region_is_child_of_region (const region * child, const region * r)
130	{
131
132	if (r == NULL)
133	return -1;
134
135	if (child == NULL)
136	return 0;
137
138	if (!strcmp (child->name, r->name))
139	return 1;
140
141	else if (child->parent != NULL)
142	return region_is_child_of_region (child->parent, r);
143	else
144	return 0;
145	}
146
147	/** Returns an object which is an exit through which the player represented by op should be
148	* sent in order to be imprisoned. If there is no suitable place to which an exit can be
149	* constructed, then NULL will be returned. The caller is responsible for freeing the object
150	* created by this function.
151	*/
152	object *
153	get_jail_exit (object *op)
154	{
155	region *reg;
156	object *exit;
157
158	if (op->type != PLAYER)
159	{
160	LOG (llevError, "region.c: get_jail_exit called against non-player object.\n");
161	return NULL;
162	}
163
164	reg = op->region ();
165	while (reg)
166	{
167	if (reg->jailmap)
168	{
169	exit = object::create ();
170	EXIT_PATH (exit) = reg->jailmap;
171	/* damned exits reset savebed and remove teleports, so the prisoner can't escape */
172	SET_FLAG (exit, FLAG_DAMNED);
173	EXIT_X (exit) = reg->jailx;
174	EXIT_Y (exit) = reg->jaily;
175	return exit;
176	}
177	else
178	reg = reg->parent;
179	}
180
181	LOG (llevError, "No suitable jailmap for region %s was found.\n", &reg->name);
182
183	return 0;
184	}
185
186	region *
187	region::load (object_f &f)
188	{
189	region *rgn = new region;
190	f.get (rgn->name);
191	f.next_kv ();
192
193	for (;;)
194	{
195	switch (f.kw)
196	{
197	case KW_parent:
198	rgn->parent = region::find (f.get_str ());
199	break;
200
201	case KW_longname:
202	f.get (rgn->longname);
203	break;
204
205	case KW_jail_map:
206	f.get (rgn->jailmap);
207	break;
208
209	case KW_jail_x:
210	f.get (rgn->jailx);
211	break;
212
213	case KW_jail_y:
214	f.get (rgn->jaily);
215	break;
216
217	case KW_msg:
218	f.get_ml (KW_endmsg, rgn->msg);
219	break;
220
221	case KW_fallback:
222	f.get (rgn->fallback);
223	break;
224
225	case KW_end:
226	for_all_regions (old)
227	if (old->name == rgn->name)
228	{
229	// replace, copy new values (ugly)
230	rgn->index = old->index;
231	old = rgn;
232	delete rgn;
233
234	return old;
235	}
236
237	// just append
238	regions.push_back (rgn);
239	return rgn;
240
241	default:
242	if (!f.parse_error ("region", rgn->name))
243	{
244	delete rgn;
245	return 0;
246	}
247	break;
248	}
249
250	f.next_kv ();
251	}
252	}
253
254	/*
255	* First initialises the archtype hash-table (init_archetable()).
256	* Reads and parses the archetype file (with the first and second-pass
257	* functions).
258	* Then initialises treasures by calling load_treasures().
259	*/
260	void
261	init_regions (void)
262	{
263	if (!regions.size ())
264	{
265	// make sure one region is always available
266	region *rgn = new region;
267	rgn->name = "<builtin>";
268	rgn->longname = "Built-in Region";
269	regions.push_back (rgn);
270	}
271	}
272