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.24 by root, Sat Feb 17 23:32:11 2007 UTC

1/* 1/*
2 * static char *rcsid_style_c = 2 * CrossFire, A Multiplayer game for X-windows
3 * "$Id: style.C,v 1.1 2006/08/13 17:16:03 elmex Exp $"; 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>
4 */ 23 */
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 24
30#include <global.h> 25#include <global.h>
31#include <random_map.h> 26#include <random_map.h>
32#ifndef WIN32 /* ---win32 exclude headers */
33#include <dirent.h> 27#include <dirent.h>
34#include <sys/stat.h> 28#include <sys/stat.h>
35#include <unistd.h> 29#include <unistd.h>
36#include "../include/autoconf.h" 30#include "../include/autoconf.h"
37#endif /* win32 */
38 31
39 32static int
40static int pointer_strcmp(const void *p1, const void *p2) 33pointer_strcmp (const void *p1, const void *p2)
41{ 34{
42 const char *s1 = *(const char **)p1; 35 const char *s1 = *(const char **) p1;
43 const char *s2 = *(const char **)p2; 36 const char *s2 = *(const char **) p2;
44 37
45 return(strcmp(s1, s2)); 38 return (strcmp (s1, s2));
46} 39}
47 40
48/* This is our own version of scandir/select_regular_files/sort. 41/* This is our own version of scandir/select_regular_files/sort.
49 * To support having subdirectories in styles, we need to know 42 * To support having subdirectories in styles, we need to know
50 * if in fact the directory we read is a subdirectory. However, 43 * if in fact the directory we read is a subdirectory. However,
… …
57 * skip_dirs controls our behavioru - if nonzero, we don't 50 * skip_dirs controls our behavioru - if nonzero, we don't
58 * skip any subdirectories - if zero, we store those away, 51 * skip any subdirectories - if zero, we store those away,
59 * since there are cases where we want to choose a random 52 * since there are cases where we want to choose a random
60 * directory. 53 * directory.
61 */ 54 */
55int
62int load_dir (const char *dir, char ***namelist, int skip_dirs) 56load_dir (const char *dir, char ***namelist, int skip_dirs)
63{ 57{
64 DIR *dp; 58 DIR *dp;
65 struct dirent *d; 59 struct dirent *d;
66 int entries=0, entry_size=0; 60 int entries = 0, entry_size = 0;
67 char name[NAME_MAX+1], **rn=NULL; 61 char name[NAME_MAX + 1], **rn = NULL;
68 struct stat sb; 62 struct stat sb;
69 63
70 dp = opendir (dir); 64 dp = opendir (dir);
71 if (dp == NULL) 65 if (!dp)
72 return -1; 66 return -1;
73 67
74 while ((d = readdir (dp)) != NULL) { 68 while ((d = readdir (dp)))
69 {
75 sprintf(name, "%s/%s", dir, d->d_name); 70 sprintf (name, "%s/%s", dir, d->d_name);
76 if (skip_dirs) { 71 if (skip_dirs)
72 {
77 stat(name, &sb); 73 stat (name, &sb);
78 if (S_ISDIR(sb.st_mode)) { 74 if (S_ISDIR (sb.st_mode))
79 continue; 75 continue;
80 } 76 }
81 }
82 77
83 if (entries == entry_size) { 78 if (entries == entry_size)
79 {
84 entry_size+=10; 80 entry_size += 10;
85 rn = (char **) realloc(rn, sizeof(char*) * entry_size); 81 rn = (char **) realloc (rn, sizeof (char *) * entry_size);
86 } 82 }
87 rn[entries] = strdup_local(d->d_name); 83 rn[entries] = strdup (d->d_name);
88 entries++; 84 entries++;
89 85
90 } 86 }
91 (void) closedir (dp); 87 (void) closedir (dp);
92 88
93 qsort(rn, entries, sizeof(char*), pointer_strcmp); 89 qsort (rn, entries, sizeof (char *), pointer_strcmp);
94 90
95 *namelist = rn; 91 *namelist = rn;
96 return entries; 92 return entries;
97} 93}
98 94
99 95maptile *
100 96find_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{ 97{
118 mapstruct *style_map; 98 char style_file_path[1024];
99 char style_file_full_path[1024];
100 maptile *style_map = NULL;
101 struct stat file_stat;
102 int i, only_subdirs = 0;
119 103
120 /* Given a file. See if its in memory */ 104 /* if stylename exists, set style_file_path to that file. */
121 for (style_map = styles; style_map!=NULL; style_map=style_map->next) { 105 if (stylename && strlen (stylename) > 0)
122 if (!strcmp(style_name, style_map->path)) return style_map; 106 sprintf (style_file_path, "%s/%s", dirname, stylename);
107 else /* otherwise, just use the dirname. We'll pick a random stylefile. */
108 sprintf (style_file_path, "%s", dirname);
109
110 /* is what we were given a directory, or a file? */
111 sprintf (style_file_full_path, "%s/maps%s.map", settings.datadir, style_file_path);
112
113 if (stat (style_file_full_path, &file_stat) == 0 && !S_ISDIR (file_stat.st_mode))
114 style_map = maptile::find_sync (style_file_path);
115
116 if (!style_map) /* maybe we were given a directory! */
117 {
118 char **namelist;
119 int n;
120 char style_dir_full_path[256];
121
122 /* get the names of all the files in that directory */
123 sprintf (style_dir_full_path, "%s/maps%s", settings.datadir, style_file_path);
124
125 /* First, skip subdirectories. If we don't find anything, then try again
126 * without skipping subdirs.
127 */
128 n = load_dir (style_dir_full_path, &namelist, 1);
129
130 if (n <= 0)
131 {
132 n = load_dir (style_dir_full_path, &namelist, 0);
133 only_subdirs = 1;
134 }
135
136 if (n <= 0)
137 return 0; /* nothing to load. Bye. */
138
139 /* Picks a random map. Note that if this is all directories,
140 * we know it won't be able to load, so save a few ticks.
141 * the door handling checks for this failure and handles
142 * it properly.
143 */
144 if (difficulty == -1)
145 { /* pick a random style from this dir. */
146 if (only_subdirs)
147 style_map = 0;
148 else
149 {
150 strcat (style_file_path, "/");
151 strcat (style_file_path, namelist[rndm (n)]);
152 style_map = maptile::find_sync (style_file_path);
153 }
154 }
155 else
156 { /* find the map closest in difficulty */
157 int min_dist = 32000, min_index = -1;
158
159 for (i = 0; i < n; i++)
160 {
161 int dist;
162 char *mfile_name = strrchr (namelist[i], '_') + 1;
163
164 if ((mfile_name - 1) == NULL)
165 { /* since there isn't a sequence, */
166 int q;
167
168 /*pick one at random to recurse */
169 style_map = find_style (style_file_path, namelist[rndm (n)], difficulty);
170 for (q = 0; q < n; q++)
171 free (namelist[q]);
172 free (namelist);
173 return style_map;
174 }
175 else
176 {
177 dist = abs (difficulty - atoi (mfile_name));
178 if (dist < min_dist)
179 {
180 min_dist = dist;
181 min_index = i;
182 }
183 }
184 }
185
186 /* presumably now we've found the "best" match for the
187 difficulty. */
188 strcat (style_file_path, "/");
189 strcat (style_file_path, namelist[min_index]);
190 style_map = maptile::find_sync (style_file_path);
191 }
192
193 for (i = 0; i < n; i++)
194 free (namelist[i]);
195
196 free (namelist);
123 } 197 }
124 style_map = load_original_map(style_name,MAP_STYLE); 198
125 /* Remove it from global list, put it on our local list */
126 if (style_map) { 199 if (style_map)
127 mapstruct *tmp; 200 {
128 201 style_map->load_sync ();
129 if (style_map == first_map) 202 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 } 203 }
204
139 return style_map; 205 return style_map;
140} 206}
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