server/random_maps/style.c

/*
 * static char *rcsid_style_c =
 *   "$Id$";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    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-devel@real-time.com
*/


#include <global.h>
#include <random_map.h>
#ifndef WIN32 /* ---win32 exclude headers */
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include "../include/autoconf.h"
#endif /* win32 */


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 = realloc(rn, sizeof(char*) * entry_size);
        }
        rn[entries] = strdup_local(d->d_name);
        entries++;

    }
    (void) closedir (dp);

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

    *namelist = rn;
    return entries;
}


/* this function loads and returns the map requested.
 * dirname, for example, is "/styles/wallstyles", stylename, is,
 * for example, "castle", difficulty is -1 when difficulty is
 * irrelevant to the style.  If dirname is given, but stylename
 * isn't, and difficult is -1, it returns a random style map.
 * Otherwise, it tries to match the difficulty given with a style
 * file, named style_name_# where # is an integer 
 */

/* remove extern, so visible to command_style_map_info function */
mapstruct *styles=NULL;


mapstruct *load_style_map(char *style_name)
{
    mapstruct *style_map;

    /* Given a file.  See if its in memory */
    for (style_map = styles; style_map!=NULL; style_map=style_map->next) {
        if (!strcmp(style_name, style_map->path)) return style_map;
    }
    style_map = load_original_map(style_name,MAP_STYLE);
    /* Remove it from global list, put it on our local list */
    if (style_map) {
        mapstruct *tmp;

        if (style_map == first_map)
            first_map = style_map->next;
        else {
            for (tmp = first_map; tmp && tmp->next != style_map; tmp = tmp->next);
            if(tmp)
                tmp->next = style_map->next;
        }
        style_map->next = styles;
        styles = style_map;
    }
    return style_map;
}

mapstruct *find_style(char *dirname,char *stylename,int difficulty) {
    char style_file_path[256];
    char style_file_full_path[256];
    mapstruct *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);
    stat(style_file_full_path,&file_stat);

    if(! (S_ISDIR(file_stat.st_mode))) {
        style_map=load_style_map(style_file_path);
    }
    if(style_map == NULL)  /* 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=NULL;
            else {
                strcat(style_file_path,"/");
                strcat(style_file_path,namelist[RANDOM()%n]);
                style_map = load_style_map(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[RANDOM()%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 = load_style_map(style_file_path);
        }
        for (i=0; i<n; i++)
            free(namelist[i]);
        free(namelist);
    }
  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(mapstruct *style) {
    int x,y, limit=0;
    object *new_obj;

    /* 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.
     */
    do {
        limit++;
        x = RANDOM() % MAP_WIDTH(style);
        y = RANDOM() % MAP_HEIGHT(style);
        new_obj = get_map_ob(style,x,y);
    } while (new_obj == NULL && limit<1000);
    if (new_obj->head) return new_obj->head;
    else return new_obj;
}
                                

void free_style_maps(void)
{
    mapstruct *next;
    int  style_maps=0;

    /* delete_map will try to free it from the linked list,
     * but won't find it, so we need to do it ourselves
     */
    while (styles) {
        next = styles->next;
        delete_map(styles);
        styles=next;
        style_maps++;
    }
    LOG(llevDebug,"free_style_maps: Freed %d maps\n", style_maps);
}

Revision:	1.2
Committed:	Sun Aug 13 17:16:03 2006 UTC (17 years, 9 months ago) by elmex
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+1 -1 lines
State:	*FILE REMOVED*
Log Message:	Made server compile with C++. Removed cfanim plugin and crossedit. C++ here we come.
#	User	Rev	Content
1	root	1.1	/*
2			* static char *rcsid_style_c =
3	elmex	1.2	* "$Id$";
4	root	1.1	*/
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
30			#include <global.h>
31			#include <random_map.h>
32			#ifndef WIN32 /* ---win32 exclude headers */
33			#include <dirent.h>
34			#include <sys/stat.h>
35			#include <unistd.h>
36			#include "../include/autoconf.h"
37			#endif /* win32 */
38
39
40			static int pointer_strcmp(const void p1, const void p2)
41			{
42			const char s1 = (const char **)p1;
43			const char s2 = (const char **)p2;
44
45			return(strcmp(s1, s2));
46			}
47
48			/* This is our own version of scandir/select_regular_files/sort.
49			* To support having subdirectories in styles, we need to know
50			* if in fact the directory we read is a subdirectory. However,
51			* we can't get that through the normal dirent entry. So
52			* instead, we do our own where we do have the full directory
53			* path so can do stat calls to see if in fact it is a directory.
54			* dir is the name of the director to scan.
55			* namelist is the array of file names returned. IT needs to be
56			* freed by the caller.
57			* skip_dirs controls our behavioru - if nonzero, we don't
58			* skip any subdirectories - if zero, we store those away,
59			* since there are cases where we want to choose a random
60			* directory.
61			*/
62			int load_dir (const char dir, char **namelist, int skip_dirs)
63			{
64			DIR *dp;
65			struct dirent *d;
66			int entries=0, entry_size=0;
67			char name[NAME_MAX+1], **rn=NULL;
68			struct stat sb;
69
70			dp = opendir (dir);
71			if (dp == NULL)
72			return -1;
73
74			while ((d = readdir (dp)) != NULL) {
75			sprintf(name, "%s/%s", dir, d->d_name);
76			if (skip_dirs) {
77			stat(name, &sb);
78			if (S_ISDIR(sb.st_mode)) {
79			continue;
80			}
81			}
82
83			if (entries == entry_size) {
84			entry_size+=10;
85			rn = realloc(rn, sizeof(char) entry_size);
86			}
87			rn[entries] = strdup_local(d->d_name);
88			entries++;
89
90			}
91			(void) closedir (dp);
92
93			qsort(rn, entries, sizeof(char*), pointer_strcmp);
94
95			*namelist = rn;
96			return entries;
97			}
98
99
100
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 */
113			mapstruct *styles=NULL;
114
115
116			mapstruct load_style_map(char style_name)
117			{
118			mapstruct *style_map;
119
120			/* Given a file. See if its in memory */
121			for (style_map = styles; style_map!=NULL; style_map=style_map->next) {
122			if (!strcmp(style_name, style_map->path)) return style_map;
123			}
124			style_map = load_original_map(style_name,MAP_STYLE);
125			/* Remove it from global list, put it on our local list */
126			if (style_map) {
127			mapstruct *tmp;
128
129			if (style_map == first_map)
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			}
139			return style_map;
140			}
141
142			mapstruct find_style(char dirname,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			stat(style_file_full_path,&file_stat);
158
159			if(! (S_ISDIR(file_stat.st_mode))) {
160			style_map=load_style_map(style_file_path);
161			}
162			if(style_map == NULL) /* maybe we were given a directory! */
163			{
164			char **namelist;
165			int n;
166			char style_dir_full_path[256];
167
168			/* get the names of all the files in that directory */
169			sprintf(style_dir_full_path,"%s/maps%s",settings.datadir,style_file_path);
170
171			/* First, skip subdirectories. If we don't find anything, then try again
172			* without skipping subdirs.
173			*/
174			n = load_dir(style_dir_full_path, &namelist, 1);
175
176			if (n<=0) {
177			n = load_dir(style_dir_full_path, &namelist, 0);
178			only_subdirs=1;
179			}
180
181			if (n<=0) return 0; /* nothing to load. Bye. */
182
183			/* Picks a random map. Note that if this is all directories,
184			* we know it won't be able to load, so save a few ticks.
185			* the door handling checks for this failure and handles
186			* it properly.
187			*/
188			if(difficulty==-1) { /* pick a random style from this dir. */
189			if (only_subdirs)
190			style_map=NULL;
191			else {
192			strcat(style_file_path,"/");
193			strcat(style_file_path,namelist[RANDOM()%n]);
194			style_map = load_style_map(style_file_path);
195			}
196			}
197			else { /* find the map closest in difficulty */
198			int min_dist=32000,min_index=-1;
199
200			for(i=0;i<n;i++) {
201			int dist;
202			char *mfile_name = strrchr(namelist[i],'_')+1;
203
204			if((mfile_name-1) == NULL) { /* since there isn't a sequence, */
205			int q;
206			/pick one at random to recurse /
207			style_map= find_style(style_file_path,
208			namelist[RANDOM()%n],difficulty);
209			for (q=0; q<n; q++)
210			free(namelist[q]);
211			free(namelist);
212			return style_map;
213			} else {
214			dist = abs(difficulty-atoi(mfile_name));
215			if(dist<min_dist) {
216			min_dist = dist;
217			min_index = i;
218			}
219			}
220			}
221			/* presumably now we've found the "best" match for the
222			difficulty. */
223			strcat(style_file_path,"/");
224			strcat(style_file_path,namelist[min_index]);
225			style_map = load_style_map(style_file_path);
226			}
227			for (i=0; i<n; i++)
228			free(namelist[i]);
229			free(namelist);
230			}
231			return style_map;
232
233			}
234
235
236			/* picks a random object from a style map.
237			* Redone by MSW so it should be faster and not use static
238			* variables to generate tables.
239			*/
240			object pick_random_object(mapstruct style) {
241			int x,y, limit=0;
242			object *new_obj;
243
244			/* while returning a null object will result in a crash, that
245			* is actually preferable to an infinite loop. That is because
246			* most servers will automatically restart in case of crash.
247			* Change the logic on getting the random space - shouldn't make
248			* any difference, but this seems clearer to me.
249			*/
250			do {
251			limit++;
252			x = RANDOM() % MAP_WIDTH(style);
253			y = RANDOM() % MAP_HEIGHT(style);
254			new_obj = get_map_ob(style,x,y);
255			} while (new_obj == NULL && limit<1000);
256			if (new_obj->head) return new_obj->head;
257			else return new_obj;
258			}
259
260
261			void free_style_maps(void)
262			{
263			mapstruct *next;
264			int style_maps=0;
265
266			/* delete_map will try to free it from the linked list,
267			* but won't find it, so we need to do it ourselves
268			*/
269			while (styles) {
270			next = styles->next;
271			delete_map(styles);
272			styles=next;
273			style_maps++;
274			}
275			LOG(llevDebug,"free_style_maps: Freed %d maps\n", style_maps);
276			}
277