server/random_maps/style.C

/*
 * CrossFire, A Multiplayer game for X-windows
 * 
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * Copyright (C) 2002 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 <random_map.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include "../include/autoconf.h"

static int
pointer_strcmp (const void *p1, const void *p2)
{
  const char *s1 = *(const char **) p1;
  const char *s2 = *(const char **) p2;

  return (strcmp (s1, s2));
}

/* This is our own version of scandir/select_regular_files/sort.
 * To support having subdirectories in styles, we need to know
 * if in fact the directory we read is a subdirectory.  However,
 * we can't get that through the normal dirent entry.  So
 * instead, we do our own where we do have the full directory
 * path so can do stat calls to see if in fact it is a directory.
 * dir is the name of the director to scan.
 * namelist is the array of file names returned.  IT needs to be
 * freed by the caller.
 * skip_dirs controls our behavioru - if nonzero, we don't
 * skip any subdirectories - if zero, we store those away,
 * since there are cases where we want to choose a random
 * directory. 
 */
int
load_dir (const char *dir, char ***namelist, int skip_dirs)
{
  DIR *dp;
  struct dirent *d;
  int entries = 0, entry_size = 0;
  char name[NAME_MAX + 1], **rn = NULL;
  struct stat sb;

  dp = opendir (dir);
  if (dp == NULL)
    return -1;

  while ((d = readdir (dp)) != NULL)
    {
      sprintf (name, "%s/%s", dir, d->d_name);
      if (skip_dirs)
        {
          stat (name, &sb);
          if (S_ISDIR (sb.st_mode))
            {
              continue;
            }
        }

      if (entries == entry_size)
        {
          entry_size += 10;
          rn = (char **) realloc (rn, sizeof (char *) * entry_size);
        }
      rn[entries] = strdup (d->d_name);
      entries++;

    }
  (void) closedir (dp);

  qsort (rn, entries, sizeof (char *), pointer_strcmp);

  *namelist = rn;
  return entries;
}

maptile *
find_style (const char *dirname, const char *stylename, int difficulty)
{
  char style_file_path[1024];
  char style_file_full_path[1024];
  maptile *style_map = NULL;
  struct stat file_stat;
  int i, only_subdirs = 0;

  /* if stylename exists, set style_file_path to that file. */
  if (stylename && strlen (stylename) > 0)
    sprintf (style_file_path, "%s/%s", dirname, stylename);
  else                          /* otherwise, just use the dirname.  We'll pick a random stylefile. */
    sprintf (style_file_path, "%s", dirname);

  /* is what we were given a directory, or a file? */
  sprintf (style_file_full_path, "%s/maps%s", settings.datadir, style_file_path);

  if (stat (style_file_full_path, &file_stat) == 0 && !S_ISDIR (file_stat.st_mode))
    style_map = maptile::find_sync (style_file_path);

  if (!style_map)               /* maybe we were given a directory! */
    {
      char **namelist;
      int n;
      char style_dir_full_path[256];

      /* get the names of all the files in that directory */
      sprintf (style_dir_full_path, "%s/maps%s", settings.datadir, style_file_path);

      /* First, skip subdirectories.  If we don't find anything, then try again
       * without skipping subdirs.
       */
      n = load_dir (style_dir_full_path, &namelist, 1);

      if (n <= 0)
        {
          n = load_dir (style_dir_full_path, &namelist, 0);
          only_subdirs = 1;
        }

      if (n <= 0)
        return 0;               /* nothing to load.  Bye. */

      /* Picks a random map.  Note that if this is all directories,
       * we know it won't be able to load, so save a few ticks.   
       * the door handling checks for this failure and handles
       * it properly.
       */
      if (difficulty == -1)
        {                       /* pick a random style from this dir. */
          if (only_subdirs)
            style_map = 0;
          else
            {
              strcat (style_file_path, "/");
              strcat (style_file_path, namelist[rndm (n)]);
              style_map = maptile::find_sync (style_file_path);
            }
        }
      else
        {                       /* find the map closest in difficulty */
          int min_dist = 32000, min_index = -1;

          for (i = 0; i < n; i++)
            {
              int dist;
              char *mfile_name = strrchr (namelist[i], '_') + 1;

              if ((mfile_name - 1) == NULL)
                {               /* since there isn't a sequence, */
                  int q;

                  /*pick one at random to recurse */
                  style_map = find_style (style_file_path, namelist[rndm (n)], difficulty);
                  for (q = 0; q < n; q++)
                    free (namelist[q]);
                  free (namelist);
                  return style_map;
                }
              else
                {
                  dist = abs (difficulty - atoi (mfile_name));
                  if (dist < min_dist)
                    {
                      min_dist = dist;
                      min_index = i;
                    }
                }
            }

          /* presumably now we've found the "best" match for the
             difficulty. */
          strcat (style_file_path, "/");
          strcat (style_file_path, namelist[min_index]);
          style_map = maptile::find_sync (style_file_path);
        }

      for (i = 0; i < n; i++)
        free (namelist[i]);

      free (namelist);
    }

  if (style_map)
    {
      style_map->load_sync ();
      style_map->deactivate ();
    }

  return style_map;

}

/* picks a random object from a style map.
 * Redone by MSW so it should be faster and not use static
 * variables to generate tables.
 */
object *
pick_random_object (maptile *style)
{
  /* while returning a null object will result in a crash, that
   * is actually preferable to an infinite loop.  That is because
   * most servers will automatically restart in case of crash.
   * Change the logic on getting the random space - shouldn't make
   * any difference, but this seems clearer to me.
   */
  for (int i = 1000; --i;)
    {
      object *new_obj = style->at (rndm (style->width), rndm (style->height)).bot;

      if (new_obj)
        return new_obj->head_ ();
    }

  // instead of crashing in the unlikely case, try to return *something*
  return get_archetype ("blocked");
}
Revision:	1.22
Committed:	Sat Jan 27 02:19:37 2007 UTC (17 years, 4 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.21:	+3 -3 lines
Log Message:	- experimentall.y determine minimum random map size (12) - harden random map generator by stresstesting - reduced codesize while increasing readability (RANDOM => rndm) - fixed a likely unimportant bug in random_roll64 - possibly broke lots of code
#	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) 2002 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 <random_map.h>
27	#include <dirent.h>
28	#include <sys/stat.h>
29	#include <unistd.h>
30	#include "../include/autoconf.h"
31
32	static int
33	pointer_strcmp (const void p1, const void p2)
34	{
35	const char s1 = (const char **) p1;
36	const char s2 = (const char **) p2;
37
38	return (strcmp (s1, s2));
39	}
40
41	/* This is our own version of scandir/select_regular_files/sort.
42	* To support having subdirectories in styles, we need to know
43	* if in fact the directory we read is a subdirectory. However,
44	* we can't get that through the normal dirent entry. So
45	* instead, we do our own where we do have the full directory
46	* path so can do stat calls to see if in fact it is a directory.
47	* dir is the name of the director to scan.
48	* namelist is the array of file names returned. IT needs to be
49	* freed by the caller.
50	* skip_dirs controls our behavioru - if nonzero, we don't
51	* skip any subdirectories - if zero, we store those away,
52	* since there are cases where we want to choose a random
53	* directory.
54	*/
55	int
56	load_dir (const char dir, char **namelist, int skip_dirs)
57	{
58	DIR *dp;
59	struct dirent *d;
60	int entries = 0, entry_size = 0;
61	char name[NAME_MAX + 1], **rn = NULL;
62	struct stat sb;
63
64	dp = opendir (dir);
65	if (dp == NULL)
66	return -1;
67
68	while ((d = readdir (dp)) != NULL)
69	{
70	sprintf (name, "%s/%s", dir, d->d_name);
71	if (skip_dirs)
72	{
73	stat (name, &sb);
74	if (S_ISDIR (sb.st_mode))
75	{
76	continue;
77	}
78	}
79
80	if (entries == entry_size)
81	{
82	entry_size += 10;
83	rn = (char *) realloc (rn, sizeof (char ) * entry_size);
84	}
85	rn[entries] = strdup (d->d_name);
86	entries++;
87
88	}
89	(void) closedir (dp);
90
91	qsort (rn, entries, sizeof (char *), pointer_strcmp);
92
93	*namelist = rn;
94	return entries;
95	}
96
97	maptile *
98	find_style (const char dirname, const char stylename, int difficulty)
99	{
100	char style_file_path[1024];
101	char style_file_full_path[1024];
102	maptile *style_map = NULL;
103	struct stat file_stat;
104	int i, only_subdirs = 0;
105
106	/* if stylename exists, set style_file_path to that file. */
107	if (stylename && strlen (stylename) > 0)
108	sprintf (style_file_path, "%s/%s", dirname, stylename);
109	else /* otherwise, just use the dirname. We'll pick a random stylefile. */
110	sprintf (style_file_path, "%s", dirname);
111
112	/* is what we were given a directory, or a file? */
113	sprintf (style_file_full_path, "%s/maps%s", settings.datadir, style_file_path);
114
115	if (stat (style_file_full_path, &file_stat) == 0 && !S_ISDIR (file_stat.st_mode))
116	style_map = maptile::find_sync (style_file_path);
117
118	if (!style_map) /* maybe we were given a directory! */
119	{
120	char **namelist;
121	int n;
122	char style_dir_full_path[256];
123
124	/* get the names of all the files in that directory */
125	sprintf (style_dir_full_path, "%s/maps%s", settings.datadir, style_file_path);
126
127	/* First, skip subdirectories. If we don't find anything, then try again
128	* without skipping subdirs.
129	*/
130	n = load_dir (style_dir_full_path, &namelist, 1);
131
132	if (n <= 0)
133	{
134	n = load_dir (style_dir_full_path, &namelist, 0);
135	only_subdirs = 1;
136	}
137
138	if (n <= 0)
139	return 0; /* nothing to load. Bye. */
140
141	/* Picks a random map. Note that if this is all directories,
142	* we know it won't be able to load, so save a few ticks.
143	* the door handling checks for this failure and handles
144	* it properly.
145	*/
146	if (difficulty == -1)
147	{ /* pick a random style from this dir. */
148	if (only_subdirs)
149	style_map = 0;
150	else
151	{
152	strcat (style_file_path, "/");
153	strcat (style_file_path, namelist[rndm (n)]);
154	style_map = maptile::find_sync (style_file_path);
155	}
156	}
157	else
158	{ /* find the map closest in difficulty */
159	int min_dist = 32000, min_index = -1;
160
161	for (i = 0; i < n; i++)
162	{
163	int dist;
164	char *mfile_name = strrchr (namelist[i], '_') + 1;
165
166	if ((mfile_name - 1) == NULL)
167	{ /* since there isn't a sequence, */
168	int q;
169
170	/pick one at random to recurse /
171	style_map = find_style (style_file_path, namelist[rndm (n)], difficulty);
172	for (q = 0; q < n; q++)
173	free (namelist[q]);
174	free (namelist);
175	return style_map;
176	}
177	else
178	{
179	dist = abs (difficulty - atoi (mfile_name));
180	if (dist < min_dist)
181	{
182	min_dist = dist;
183	min_index = i;
184	}
185	}
186	}
187
188	/* presumably now we've found the "best" match for the
189	difficulty. */
190	strcat (style_file_path, "/");
191	strcat (style_file_path, namelist[min_index]);
192	style_map = maptile::find_sync (style_file_path);
193	}
194
195	for (i = 0; i < n; i++)
196	free (namelist[i]);
197
198	free (namelist);
199	}
200
201	if (style_map)
202	{
203	style_map->load_sync ();
204	style_map->deactivate ();
205	}
206
207	return style_map;
208
209	}
210
211	/* picks a random object from a style map.
212	* Redone by MSW so it should be faster and not use static
213	* variables to generate tables.
214	*/
215	object *
216	pick_random_object (maptile *style)
217	{
218	/* while returning a null object will result in a crash, that
219	* is actually preferable to an infinite loop. That is because
220	* most servers will automatically restart in case of crash.
221	* Change the logic on getting the random space - shouldn't make
222	* any difference, but this seems clearer to me.
223	*/
224	for (int i = 1000; --i;)
225	{
226	object *new_obj = style->at (rndm (style->width), rndm (style->height)).bot;
227
228	if (new_obj)
229	return new_obj->head_ ();
230	}
231
232	// instead of crashing in the unlikely case, try to return something
233	return get_archetype ("blocked");
234	}