ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/random_maps/style.C
(Generate patch)

Comparing deliantra/server/random_maps/style.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:03 2006 UTC vs.
Revision 1.27 by root, Thu Nov 8 19:43:25 2007 UTC

1/* 1/*
2 * static char *rcsid_style_c = 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * "$Id: style.C,v 1.1 2006/08/13 17:16:03 elmex Exp $"; 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,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>
4 */ 22 */
5
6/*
7 CrossFire, A Multiplayer game for X-windows
8
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
26 The authors can be reached via e-mail at crossfire-devel@real-time.com
27*/
28
29 23
30#include <global.h> 24#include <global.h>
31#include <random_map.h> 25#include <random_map.h>
32#ifndef WIN32 /* ---win32 exclude headers */
33#include <dirent.h> 26#include <dirent.h>
34#include <sys/stat.h> 27#include <sys/stat.h>
35#include <unistd.h> 28#include <unistd.h>
36#include "../include/autoconf.h" 29#include "../include/autoconf.h"
37#endif /* win32 */
38 30
31// NAME_MAX may not be defined on POSIX systems
32#ifndef NAME_MAX
33# define NAME_MAX 255
34#endif
39 35
36static int
40static int pointer_strcmp(const void *p1, const void *p2) 37pointer_strcmp (const void *p1, const void *p2)
41{ 38{
42 const char *s1 = *(const char **)p1; 39 const char *s1 = *(const char **) p1;
43 const char *s2 = *(const char **)p2; 40 const char *s2 = *(const char **) p2;
44 41
45 return(strcmp(s1, s2)); 42 return (strcmp (s1, s2));
46} 43}
47 44
48/* This is our own version of scandir/select_regular_files/sort. 45/* This is our own version of scandir/select_regular_files/sort.
49 * To support having subdirectories in styles, we need to know 46 * To support having subdirectories in styles, we need to know
50 * if in fact the directory we read is a subdirectory. However, 47 * if in fact the directory we read is a subdirectory. However,
… …
57 * skip_dirs controls our behavioru - if nonzero, we don't 54 * skip_dirs controls our behavioru - if nonzero, we don't
58 * skip any subdirectories - if zero, we store those away, 55 * skip any subdirectories - if zero, we store those away,
59 * since there are cases where we want to choose a random 56 * since there are cases where we want to choose a random
60 * directory. 57 * directory.
61 */ 58 */
59int
62int load_dir (const char *dir, char ***namelist, int skip_dirs) 60load_dir (const char *dir, char ***namelist, int skip_dirs)
63{ 61{
64 DIR *dp; 62 DIR *dp;
65 struct dirent *d; 63 struct dirent *d;
66 int entries=0, entry_size=0; 64 int entries = 0, entry_size = 0;
67 char name[NAME_MAX+1], **rn=NULL; 65 char name[NAME_MAX + 1], **rn = NULL;
68 struct stat sb; 66 struct stat sb;
69 67
70 dp = opendir (dir); 68 dp = opendir (dir);
71 if (dp == NULL) 69 if (!dp)
72 return -1; 70 return -1;
73 71
74 while ((d = readdir (dp)) != NULL) { 72 while ((d = readdir (dp)))
73 {
75 sprintf(name, "%s/%s", dir, d->d_name); 74 sprintf (name, "%s/%s", dir, d->d_name);
76 if (skip_dirs) { 75 if (skip_dirs)
76 {
77 stat(name, &sb); 77 stat (name, &sb);
78 if (S_ISDIR(sb.st_mode)) { 78 if (S_ISDIR (sb.st_mode))
79 continue; 79 continue;
80 } 80 }
81 }
82 81
83 if (entries == entry_size) { 82 if (entries == entry_size)
83 {
84 entry_size+=10; 84 entry_size += 10;
85 rn = (char **) realloc(rn, sizeof(char*) * entry_size); 85 rn = (char **) realloc (rn, sizeof (char *) * entry_size);
86 } 86 }
87 rn[entries] = strdup_local(d->d_name); 87 rn[entries] = strdup (d->d_name);
88 entries++; 88 entries++;
89 89
90 } 90 }
91 (void) closedir (dp); 91 (void) closedir (dp);
92 92
93 qsort(rn, entries, sizeof(char*), pointer_strcmp); 93 qsort (rn, entries, sizeof (char *), pointer_strcmp);
94 94
95 *namelist = rn; 95 *namelist = rn;
96 return entries; 96 return entries;
97} 97}
98 98
99 99maptile *
100 100find_style (const char *dirname, const char *stylename, int difficulty)
101
102
103/* this function loads and returns the map requested.
104 * dirname, for example, is "/styles/wallstyles", stylename, is,
105 * for example, "castle", difficulty is -1 when difficulty is
106 * irrelevant to the style. If dirname is given, but stylename
107 * isn't, and difficult is -1, it returns a random style map.
108 * Otherwise, it tries to match the difficulty given with a style
109 * file, named style_name_# where # is an integer
110 */
111
112/* remove extern, so visible to command_style_map_info function */
113mapstruct *styles=NULL;
114
115
116mapstruct *load_style_map(char *style_name)
117{ 101{
118 mapstruct *style_map; 102 char style_file_path[1024];
103 char style_file_full_path[1024];
104 maptile *style_map = NULL;
105 struct stat file_stat;
106 int i, only_subdirs = 0;
119 107
120 /* Given a file. See if its in memory */ 108 /* if stylename exists, set style_file_path to that file. */
121 for (style_map = styles; style_map!=NULL; style_map=style_map->next) { 109 if (stylename && strlen (stylename) > 0)
122 if (!strcmp(style_name, style_map->path)) return style_map; 110 sprintf (style_file_path, "%s/%s", dirname, stylename);
111 else /* otherwise, just use the dirname. We'll pick a random stylefile. */
112 sprintf (style_file_path, "%s", dirname);
113
114 /* is what we were given a directory, or a file? */
115 sprintf (style_file_full_path, "%s/maps%s.map", settings.datadir, style_file_path);
116
117 if (stat (style_file_full_path, &file_stat) == 0 && !S_ISDIR (file_stat.st_mode))
118 style_map = maptile::find_sync (style_file_path);
119
120 if (!style_map) /* maybe we were given a directory! */
121 {
122 char **namelist;
123 int n;
124 char style_dir_full_path[256];
125
126 /* get the names of all the files in that directory */
127 sprintf (style_dir_full_path, "%s/maps%s", settings.datadir, style_file_path);
128
129 /* First, skip subdirectories. If we don't find anything, then try again
130 * without skipping subdirs.
131 */
132 n = load_dir (style_dir_full_path, &namelist, 1);
133
134 if (n <= 0)
135 {
136 n = load_dir (style_dir_full_path, &namelist, 0);
137 only_subdirs = 1;
138 }
139
140 if (n <= 0)
141 return 0; /* nothing to load. Bye. */
142
143 /* Picks a random map. Note that if this is all directories,
144 * we know it won't be able to load, so save a few ticks.
145 * the door handling checks for this failure and handles
146 * it properly.
147 */
148 if (difficulty == -1)
149 { /* pick a random style from this dir. */
150 if (only_subdirs)
151 style_map = 0;
152 else
153 {
154 strcat (style_file_path, "/");
155 strcat (style_file_path, namelist[rndm (n)]);
156 style_map = maptile::find_sync (style_file_path);
157 }
158 }
159 else
160 { /* find the map closest in difficulty */
161 int min_dist = 32000, min_index = -1;
162
163 for (i = 0; i < n; i++)
164 {
165 int dist;
166 char *mfile_name = strrchr (namelist[i], '_') + 1;
167
168 if ((mfile_name - 1) == NULL)
169 { /* since there isn't a sequence, */
170 int q;
171
172 /*pick one at random to recurse */
173 style_map = find_style (style_file_path, namelist[rndm (n)], difficulty);
174 for (q = 0; q < n; q++)
175 free (namelist[q]);
176 free (namelist);
177 return style_map;
178 }
179 else
180 {
181 dist = abs (difficulty - atoi (mfile_name));
182 if (dist < min_dist)
183 {
184 min_dist = dist;
185 min_index = i;
186 }
187 }
188 }
189
190 /* presumably now we've found the "best" match for the
191 difficulty. */
192 strcat (style_file_path, "/");
193 strcat (style_file_path, namelist[min_index]);
194 style_map = maptile::find_sync (style_file_path);
195 }
196
197 for (i = 0; i < n; i++)
198 free (namelist[i]);
199
200 free (namelist);
123 } 201 }
124 style_map = load_original_map(style_name,MAP_STYLE); 202
125 /* Remove it from global list, put it on our local list */
126 if (style_map) { 203 if (style_map)
127 mapstruct *tmp; 204 {
128 205 style_map->load_sync ();
129 if (style_map == first_map) 206 style_map->deactivate ();
130 first_map = style_map->next;
131 else {
132 for (tmp = first_map; tmp && tmp->next != style_map; tmp = tmp->next);
133 if(tmp)
134 tmp->next = style_map->next;
135 }
136 style_map->next = styles;
137 styles = style_map;
138 } 207 }
208
139 return style_map; 209 return style_map;
140} 210}
141
142mapstruct *find_style(const char *dirname,const char *stylename,int difficulty) {
143 char style_file_path[256];
144 char style_file_full_path[256];
145 mapstruct *style_map = NULL;
146 struct stat file_stat;
147 int i, only_subdirs=0;
148
149 /* if stylename exists, set style_file_path to that file.*/
150 if(stylename && strlen(stylename)>0)
151 sprintf(style_file_path,"%s/%s",dirname,stylename);
152 else /* otherwise, just use the dirname. We'll pick a random stylefile.*/
153 sprintf(style_file_path,"%s",dirname);
154
155 /* is what we were given a directory, or a file? */
156 sprintf(style_file_full_path,"%s/maps%s",settings.datadir,style_file_path);
157 if (stat(style_file_full_path, &file_stat) == 0
158 && !S_ISDIR(file_stat.st_mode)) {
159 style_map=load_style_map(style_file_path);
160 }
161 if(style_map == NULL) /* maybe we were given a directory! */
162 {
163 char **namelist;
164 int n;
165 char style_dir_full_path[256];
166
167 /* get the names of all the files in that directory */
168 sprintf(style_dir_full_path,"%s/maps%s",settings.datadir,style_file_path);
169
170 /* First, skip subdirectories. If we don't find anything, then try again
171 * without skipping subdirs.
172 */
173 n = load_dir(style_dir_full_path, &namelist, 1);
174
175 if (n<=0) {
176 n = load_dir(style_dir_full_path, &namelist, 0);
177 only_subdirs=1;
178 }
179
180 if (n<=0) return 0; /* nothing to load. Bye. */
181
182 /* Picks a random map. Note that if this is all directories,
183 * we know it won't be able to load, so save a few ticks.
184 * the door handling checks for this failure and handles
185 * it properly.
186 */
187 if(difficulty==-1) { /* pick a random style from this dir. */
188 if (only_subdirs)
189 style_map=NULL;
190 else {
191 strcat(style_file_path,"/");
192 strcat(style_file_path,namelist[RANDOM()%n]);
193 style_map = load_style_map(style_file_path);
194 }
195 }
196 else { /* find the map closest in difficulty */
197 int min_dist=32000,min_index=-1;
198
199 for(i=0;i<n;i++) {
200 int dist;
201 char *mfile_name = strrchr(namelist[i],'_')+1;
202
203 if((mfile_name-1) == NULL) { /* since there isn't a sequence, */
204 int q;
205 /*pick one at random to recurse */
206 style_map= find_style(style_file_path,
207 namelist[RANDOM()%n],difficulty);
208 for (q=0; q<n; q++)
209 free(namelist[q]);
210 free(namelist);
211 return style_map;
212 } else {
213 dist = abs(difficulty-atoi(mfile_name));
214 if(dist<min_dist) {
215 min_dist = dist;
216 min_index = i;
217 }
218 }
219 }
220 /* presumably now we've found the "best" match for the
221 difficulty. */
222 strcat(style_file_path,"/");
223 strcat(style_file_path,namelist[min_index]);
224 style_map = load_style_map(style_file_path);
225 }
226 for (i=0; i<n; i++)
227 free(namelist[i]);
228 free(namelist);
229 }
230 return style_map;
231
232}
233
234
235/* picks a random object from a style map.
236 * Redone by MSW so it should be faster and not use static
237 * variables to generate tables.
238 */
239object *pick_random_object(mapstruct *style) {
240 int x,y, limit=0;
241 object *new_obj;
242
243 /* while returning a null object will result in a crash, that
244 * is actually preferable to an infinite loop. That is because
245 * most servers will automatically restart in case of crash.
246 * Change the logic on getting the random space - shouldn't make
247 * any difference, but this seems clearer to me.
248 */
249 do {
250 limit++;
251 x = RANDOM() % MAP_WIDTH(style);
252 y = RANDOM() % MAP_HEIGHT(style);
253 new_obj = get_map_ob(style,x,y);
254 } while (new_obj == NULL && limit<1000);
255 if (new_obj->head) return new_obj->head;
256 else return new_obj;
257}
258
259
260void free_style_maps(void)
261{
262 mapstruct *next;
263 int style_maps=0;
264
265 /* delete_map will try to free it from the linked list,
266 * but won't find it, so we need to do it ourselves
267 */
268 while (styles) {
269 next = styles->next;
270 delete_map(styles);
271 styles=next;
272 style_maps++;
273 }
274 LOG(llevDebug,"free_style_maps: Freed %d maps\n", style_maps);
275}
276

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines