server/common/region.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Deliantra 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 3 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#include <global.h>
#include <unistd.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 ();
}

void
region::do_destroy ()
{
  regions.erase (this);

  attachable::do_destroy ();

  refcnt_dec ();
}

/* 
 * 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::read (object_thawer &f)
{
  assert (f.kw == KW_region);

  region *rgn = new region;
  rgn->refcnt_inc ();

  f.get (rgn->name);
  f.next ();

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

          case KW_msg:        f.get_ml (KW_endmsg, rgn->msg); 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_portal_map: f.get (rgn->portalmap);break;
          case KW_portal_x:   f.get (rgn->portalx);  break;
          case KW_portal_y:   f.get (rgn->portaly);  break;
          case KW_fallback:   f.get (rgn->fallback); break;
          case KW_chance:     f.get (rgn->treasure_density); break;

          case KW_randomitems:
            rgn->treasure = treasurelist::get (f.get_str ());
            break;

          case KW_end:
            f.next ();

            // cannot use find as that will request the default region
            for_all_regions (old)
              if (old->name == rgn->name)
                {
                  old->destroy ();
                  break;
                }

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

          case KW_ERROR:
            rgn->set_key_text (f.kw_str, f.value);
            //fprintf (stderr, "region addkv(%s,%s)\n", f.kw_str, f.value);//D
            break;

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

      f.next ();
    }
}

/*
 * First initialises the archtype hash-table (init_archetable()).
 * Reads and parses the archetype file (with the first and second-pass
 * functions).
 */
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.37
Committed:	Thu Nov 8 19:43:23 2007 UTC (16 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_4, rel-2_5, rel-2_52, rel-2_32, rel-2_43, rel-2_42, rel-2_41
Changes since 1.36:	+4 -4 lines
Log Message:	update copyrights and other minor stuff to deliantra
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Deliantra 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 3 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, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/
23
24	#include <global.h>
25	#include <unistd.h>
26
27	regionvec regions;
28
29	region *
30	region::default_region ()
31	{
32	for_all_regions (rgn)
33	if (rgn->fallback)
34	return rgn;
35
36	return regions [0];
37	}
38
39	/*
40	* Pass a char array, returns a pointer to the region of the same name.
41	* if it can't find a region of the same name it returns the first region
42	* with the 'fallback' property set.
43	* if it can't find a matching name /or/ a fallback region it logs an info message
44	* message and returns NULL
45	* used by the map parsing code.
46	*/
47	region *
48	region::find (const char *name)
49	{
50	for_all_regions (rgn)
51	if (!strcmp (rgn->name, name))
52	return rgn;
53
54	LOG (llevError, "region called %s requested, but not found, using fallback.\n", name);
55
56	return default_region ();
57	}
58
59	/*
60	* Tries to find a region that 'name' corresponds to.
61	* It looks, in order, for:
62	* an exact match to region name (case insensitive)
63	* an exact match to longname (case insensitive)
64	* a substring that matches to the longname (eg Kingdom)
65	* a substring that matches to the region name (eg nav)
66	* if it can find none of these it returns the first parentless region
67	* (there should be only one of these - the top level one)
68	* If we got a NULL, then just return the top level region
69	*
70	*/
71	region *
72	region::find_fuzzy (const char *name)
73	{
74	if (!name)
75	return default_region ();
76
77	char *p = strchr (name, '\n');
78	if (p)
79	*p = '\0';
80
81	for_all_regions (rgn)
82	if (!strcasecmp (rgn->name, name))
83	return rgn;
84
85	for_all_regions (rgn)
86	if (rgn->longname)
87	if (!strcasecmp (rgn->longname, name))
88	return rgn;
89
90	for_all_regions (rgn)
91	if (rgn->longname)
92	{
93	if (strstr (rgn->longname, name))
94	return rgn;
95	}
96
97	for_all_regions (rgn)
98	if (rgn->longname)
99	{
100	/*
101	* This is not a bug, we want the region that is most identifiably a discrete
102	* area in the game, eg if we have 'scor', we want to return 'scorn' and not
103	* 'scornarena', regardless of their order on the list so we only look at those
104	* regions with a longname set.
105	*/
106	if (strstr (rgn->name, name))
107	return rgn;
108	}
109
110	for_all_regions (rgn)
111	{
112	if (strstr (rgn->name, name))
113	return rgn;
114	}
115
116	return default_region ();
117	}
118
119	void
120	region::do_destroy ()
121	{
122	regions.erase (this);
123
124	attachable::do_destroy ();
125
126	refcnt_dec ();
127	}
128
129	/*
130	* returns 1 if the player is in the region reg, or a child region thereof
131	* otherwise returns 0
132	* if passed a NULL region returns -1
133	*/
134	static int
135	region_is_child_of_region (const region * child, const region * r)
136	{
137
138	if (r == NULL)
139	return -1;
140
141	if (child == NULL)
142	return 0;
143
144	if (!strcmp (child->name, r->name))
145	return 1;
146
147	else if (child->parent != NULL)
148	return region_is_child_of_region (child->parent, r);
149	else
150	return 0;
151	}
152
153	/** Returns an object which is an exit through which the player represented by op should be
154	* sent in order to be imprisoned. If there is no suitable place to which an exit can be
155	* constructed, then NULL will be returned. The caller is responsible for freeing the object
156	* created by this function.
157	*/
158	object *
159	get_jail_exit (object *op)
160	{
161	region *reg;
162	object *exit;
163
164	if (op->type != PLAYER)
165	{
166	LOG (llevError, "region.c: get_jail_exit called against non-player object.\n");
167	return NULL;
168	}
169
170	reg = op->region ();
171	while (reg)
172	{
173	if (reg->jailmap)
174	{
175	exit = object::create ();
176	EXIT_PATH (exit) = reg->jailmap;
177	/* damned exits reset savebed and remove teleports, so the prisoner can't escape */
178	SET_FLAG (exit, FLAG_DAMNED);
179	EXIT_X (exit) = reg->jailx;
180	EXIT_Y (exit) = reg->jaily;
181	return exit;
182	}
183	else
184	reg = reg->parent;
185	}
186
187	LOG (llevError, "No suitable jailmap for region %s was found.\n", &reg->name);
188
189	return 0;
190	}
191
192	region *
193	region::read (object_thawer &f)
194	{
195	assert (f.kw == KW_region);
196
197	region *rgn = new region;
198	rgn->refcnt_inc ();
199
200	f.get (rgn->name);
201	f.next ();
202
203	for (;;)
204	{
205	switch (f.kw)
206	{
207	case KW_parent:
208	rgn->parent = region::find (f.get_str ());
209	break;
210
211	case KW_msg: f.get_ml (KW_endmsg, rgn->msg); break;
212	case KW_longname: f.get (rgn->longname); break;
213	case KW_jail_map: f.get (rgn->jailmap); break;
214	case KW_jail_x: f.get (rgn->jailx); break;
215	case KW_jail_y: f.get (rgn->jaily); break;
216	case KW_portal_map: f.get (rgn->portalmap);break;
217	case KW_portal_x: f.get (rgn->portalx); break;
218	case KW_portal_y: f.get (rgn->portaly); break;
219	case KW_fallback: f.get (rgn->fallback); break;
220	case KW_chance: f.get (rgn->treasure_density); break;
221
222	case KW_randomitems:
223	rgn->treasure = treasurelist::get (f.get_str ());
224	break;
225
226	case KW_end:
227	f.next ();
228
229	// cannot use find as that will request the default region
230	for_all_regions (old)
231	if (old->name == rgn->name)
232	{
233	old->destroy ();
234	break;
235	}
236
237	// just append
238	regions.push_back (rgn);
239	return rgn;
240
241	case KW_ERROR:
242	rgn->set_key_text (f.kw_str, f.value);
243	//fprintf (stderr, "region addkv(%s,%s)\n", f.kw_str, f.value);//D
244	break;
245
246	default:
247	if (!f.parse_error ("region", rgn->name))
248	{
249	rgn->destroy ();
250	return 0;
251	}
252	break;
253	}
254
255	f.next ();
256	}
257	}
258
259	/*
260	* First initialises the archtype hash-table (init_archetable()).
261	* Reads and parses the archetype file (with the first and second-pass
262	* functions).
263	*/
264	void
265	init_regions (void)
266	{
267	if (!regions.size ())
268	{
269	// make sure one region is always available
270	region *rgn = new region;
271	rgn->name = "<builtin>";
272	rgn->longname = "Built-in Region";
273	regions.push_back (rgn);
274	}
275	}
276