src/d2cs/d2ladder.c

/*
 * Copyright (C) 2000,2001      Onlyer  (onlyer@263.net)
 * Copyright (C) 2001           sousou  (liupeng.cs@263.net)
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#include "common/setup_before.h"
#include "setup.h"

#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#include <stdio.h>
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
# ifdef HAVE_MEMORY_H
#  include <memory.h>
# endif
#endif
#include "compat/strcasecmp.h"
#include "compat/memset.h"
#include <errno.h>
#include "compat/strerror.h"
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif

#include "prefs.h"
#include "d2charfile.h"
#include "d2ladder.h"
#include "d2cs_protocol.h"
#include "common/tag.h"
#include "common/eventlog.h"
#include "common/xalloc.h"
#include "common/setup_after.h"

static t_d2ladder       * ladder_data=NULL;
static unsigned int     max_ladder_type=0;

static int d2ladderlist_create(unsigned int maxtype);
static int d2ladder_create(unsigned int type, unsigned int len);
static int d2ladder_append_ladder(unsigned int type, t_d2ladderfile_ladderinfo * info);
static int d2ladder_readladder(void);

extern int d2ladder_init(void)
{
        if (d2ladder_readladder()<0) {
                eventlog(eventlog_level_error,__FUNCTION__,"failed to initialize ladder data");
                return -1;
        } 
        eventlog(eventlog_level_info,__FUNCTION__,"ladder data initialized");
        return 0;
}

static int d2ladder_readladder(void)
{
        FILE                            * fp;
        t_d2ladderfile_ladderindex      * ladderheader;
        t_d2ladderfile_ladderinfo       * ladderinfo;
        char                            * ladderfile;
        t_d2ladderfile_header           header;
        unsigned int                    i, n, temp, count, type, number;

        ladderfile=xmalloc(strlen(prefs_get_ladder_dir())+1+strlen(LADDER_FILE_PREFIX)+1+
                        strlen(CLIENTTAG_DIABLO2DV)+1);
        sprintf(ladderfile,"%s/%s.%s",prefs_get_ladder_dir(),LADDER_FILE_PREFIX,CLIENTTAG_DIABLO2DV);
        if (!(fp=fopen(ladderfile,"rb"))) {
                eventlog(eventlog_level_error,__FUNCTION__,"error opening ladder file \"%s\" for reading (fopen: %s)",ladderfile,pstrerror(errno));
                xfree(ladderfile);
                return -1;
        }
        xfree(ladderfile);
        if (fread(&header,1,sizeof(header),fp)!=sizeof(header)) {
                eventlog(eventlog_level_error,__FUNCTION__,"error reading ladder file");
                fclose(fp);
                return -1;
        }
        max_ladder_type= bn_int_get(header.maxtype);
        if (d2ladderlist_create(max_ladder_type)<0) {
                eventlog(eventlog_level_error,__FUNCTION__,"error create ladder list");
                fclose(fp);
                return -1;
        }
        temp= max_ladder_type * sizeof(*ladderheader);
        ladderheader=xmalloc(temp);
        if (fread(ladderheader,1,temp,fp)!=temp) {
                eventlog(eventlog_level_error,__FUNCTION__,"error read ladder file");
                xfree(ladderheader);
                fclose(fp);
                return -1;
        }
        for (i=0, count=0; i< max_ladder_type ; i++) {
                type=bn_int_get(ladderheader[i].type);
                number=bn_int_get(ladderheader[i].number);
                if (d2ladder_create(type,number)<0) {
                        eventlog(eventlog_level_error,__FUNCTION__,"error create ladder %d",type);
                        continue;
                }
                fseek(fp,bn_int_get(ladderheader[i].offset),SEEK_SET);
                temp=number * sizeof(*ladderinfo);
                ladderinfo=xmalloc(temp);
                if (fread(ladderinfo,1,temp,fp)!=temp) {
                        eventlog(eventlog_level_error,__FUNCTION__,"error read ladder file");
                        xfree(ladderinfo);
                        continue;
                }
                for (n=0; n< number; n++) {
                        d2ladder_append_ladder(type,ladderinfo+n);
                }
                xfree(ladderinfo);
                if (number) count++;
        }
        xfree(ladderheader);
        fclose(fp);
        eventlog(eventlog_level_info,__FUNCTION__,"ladder file loaded successfully (%d types %d maxtype)",count,max_ladder_type);
        return 0;
}

static int d2ladderlist_create(unsigned int maxtype)
{
        ladder_data=xmalloc(maxtype * sizeof(*ladder_data));
        memset(ladder_data,0, maxtype * sizeof(*ladder_data));
        return 0;
}

extern int d2ladder_refresh(void)
{
        d2ladder_destroy();
        return d2ladder_readladder();
}

static int d2ladder_create(unsigned int type, unsigned int len)
{
        if (type>max_ladder_type) {
                eventlog(eventlog_level_error,__FUNCTION__,"ladder type %d exceed max ladder type %d",type,max_ladder_type);
                return -1;
        }
        ladder_data[type].info=xmalloc(sizeof(t_d2cs_client_ladderinfo) * len);
        ladder_data[type].len=len;
        ladder_data[type].type=type;
        ladder_data[type].curr_len=0;
        return 0;
}

static int d2ladder_append_ladder(unsigned int type, t_d2ladderfile_ladderinfo * info)
{
        t_d2cs_client_ladderinfo        * ladderinfo;
        unsigned short                  ladderstatus;
        unsigned short                  status;
        unsigned char                   class;

        if (!info) {
                eventlog(eventlog_level_error,__FUNCTION__,"got NULL info");
                return -1;
        }
        if (type > max_ladder_type) {
                eventlog(eventlog_level_error,__FUNCTION__,"ladder type %d exceed max ladder type %d",type,max_ladder_type);
                return -1;
        }
        if (!ladder_data[type].info) {
                eventlog(eventlog_level_error,__FUNCTION__,"ladder data info not initialized");
                return -1;
        }
        if (ladder_data[type].curr_len >= ladder_data[type].len) {
                eventlog(eventlog_level_error,__FUNCTION__,"ladder data overflow %d > %d", ladder_data[type].curr_len, ladder_data[type].len);
                return -1;
        }
        status = bn_short_get(info->status);
        class = bn_byte_get(info->class);
        ladderstatus = (status & LADDERSTATUS_FLAG_DIFFICULTY);
        if (charstatus_get_hardcore(status)) {
                ladderstatus |= LADDERSTATUS_FLAG_HARDCORE;
                if (charstatus_get_dead(status)) {
                        ladderstatus |= LADDERSTATUS_FLAG_DEAD;
                }
        }
        if (charstatus_get_expansion(status)) {
                ladderstatus |= LADDERSTATUS_FLAG_EXPANSION;
                ladderstatus |= min(class,D2CHAR_EXP_CLASS_MAX);
        } else {
                ladderstatus |= min(class,D2CHAR_CLASS_MAX);
        }
        ladderinfo=ladder_data[type].info+ladder_data[type].curr_len;
        bn_int_set(&ladderinfo->explow, bn_int_get(info->experience));
        bn_int_set(&ladderinfo->exphigh,0);
        bn_short_set(&ladderinfo->status,ladderstatus);
        bn_byte_set(&ladderinfo->level, bn_int_get(info->level));
        bn_byte_set(&ladderinfo->u1, 0);
        strncpy(ladderinfo->charname, info->charname, MAX_CHARNAME_LEN);
        ladder_data[type].curr_len++;
        return 0;
}

extern int d2ladder_destroy(void)
{
        unsigned int i;

        if (ladder_data) {
                for (i=0; i< max_ladder_type; i++) {
                        if (ladder_data[i].info) {
                                xfree(ladder_data[i].info);
                                ladder_data[i].info=NULL;
                        }
                }
                xfree(ladder_data);
                ladder_data=NULL;
        }
        max_ladder_type=0;
        return 0;
}

extern int d2ladder_get_ladder(unsigned int * from, unsigned int * count, unsigned int type,
                                        t_d2cs_client_ladderinfo const * * info)
{
        t_d2ladder      * ladder;

        if (!ladder_data) return -1;
        ladder=ladder_data+type;
        if (!ladder->curr_len || !ladder->info) {
                eventlog(eventlog_level_warn,__FUNCTION__,"ladder type %d not found",type);
                return -1;
        }
        if (ladder->type != type) {
                eventlog(eventlog_level_error,__FUNCTION__,"got bad ladder data");
                return -1;
        }
        if (ladder->curr_len < *count) {
                *from = 0;
                *count=ladder->curr_len;
        } else if (*from + *count> ladder->curr_len) {
                *from= ladder->curr_len - *count;
        }
        *info = ladder->info+ *from;
        return 0;
}

extern int d2ladder_find_character_pos(unsigned int type, char const * charname)
{
        unsigned int    i;
        t_d2ladder      * ladder;

        if (!ladder_data) return -1;
        ladder=ladder_data+type;
        if (!ladder->curr_len || !ladder->info) {
                eventlog(eventlog_level_warn,__FUNCTION__,"ladder type %d not found",type);
                return -1;
        }
        if (ladder->type != type) {
                eventlog(eventlog_level_error,__FUNCTION__,"got bad ladder data");
                return -1;
        }
        for (i=0; i< ladder->curr_len; i++) {
                if (!strcasecmp(ladder->info[i].charname,charname)) return i;
        }
        return -1;
}
1	sysadm	1.1	/*
2			* Copyright (C) 2000,2001 Onlyer (onlyer@263.net)
3			* Copyright (C) 2001 sousou (liupeng.cs@263.net)
4			*
5			* This program is free software; you can redistribute it and/or
6			* modify it under the terms of the GNU General Public License
7			* as published by the Free Software Foundation; either version 2
8			* of the License, or (at your option) any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License
16			* along with this program; if not, write to the Free Software
17			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18			*/
19			#include "common/setup_before.h"
20			#include "setup.h"
21
22			#ifdef HAVE_STDDEF_H
23			# include <stddef.h>
24			#else
25			# ifndef NULL
26			# define NULL ((void *)0)
27			# endif
28			#endif
29			#include <stdio.h>
30			#ifdef HAVE_STRING_H
31			# include <string.h>
32			#else
33			# ifdef HAVE_STRINGS_H
34			# include <strings.h>
35			# endif
36			# ifdef HAVE_MEMORY_H
37			# include <memory.h>
38			# endif
39			#endif
40			#include "compat/strcasecmp.h"
41			#include "compat/memset.h"
42			#include <errno.h>
43			#include "compat/strerror.h"
44			#ifdef STDC_HEADERS
45			# include <stdlib.h>
46			#else
47			# ifdef HAVE_MALLOC_H
48			# include <malloc.h>
49			# endif
50			#endif
51
52			#include "prefs.h"
53			#include "d2charfile.h"
54			#include "d2ladder.h"
55			#include "d2cs_protocol.h"
56			#include "common/tag.h"
57			#include "common/eventlog.h"
58			#include "common/xalloc.h"
59			#include "common/setup_after.h"
60
61			static t_d2ladder * ladder_data=NULL;
62			static unsigned int max_ladder_type=0;
63
64			static int d2ladderlist_create(unsigned int maxtype);
65			static int d2ladder_create(unsigned int type, unsigned int len);
66			static int d2ladder_append_ladder(unsigned int type, t_d2ladderfile_ladderinfo * info);
67			static int d2ladder_readladder(void);
68
69			extern int d2ladder_init(void)
70			{
71			if (d2ladder_readladder()<0) {
72			eventlog(eventlog_level_error,__FUNCTION__,"failed to initialize ladder data");
73			return -1;
74			}
75			eventlog(eventlog_level_info,__FUNCTION__,"ladder data initialized");
76			return 0;
77			}
78
79			static int d2ladder_readladder(void)
80			{
81			FILE * fp;
82			t_d2ladderfile_ladderindex * ladderheader;
83			t_d2ladderfile_ladderinfo * ladderinfo;
84			char * ladderfile;
85			t_d2ladderfile_header header;
86			unsigned int i, n, temp, count, type, number;
87
88			ladderfile=xmalloc(strlen(prefs_get_ladder_dir())+1+strlen(LADDER_FILE_PREFIX)+1+
89			strlen(CLIENTTAG_DIABLO2DV)+1);
90			sprintf(ladderfile,"%s/%s.%s",prefs_get_ladder_dir(),LADDER_FILE_PREFIX,CLIENTTAG_DIABLO2DV);
91			if (!(fp=fopen(ladderfile,"rb"))) {
92			eventlog(eventlog_level_error,__FUNCTION__,"error opening ladder file \"%s\" for reading (fopen: %s)",ladderfile,pstrerror(errno));
93			xfree(ladderfile);
94			return -1;
95			}
96			xfree(ladderfile);
97			if (fread(&header,1,sizeof(header),fp)!=sizeof(header)) {
98			eventlog(eventlog_level_error,__FUNCTION__,"error reading ladder file");
99			fclose(fp);
100			return -1;
101			}
102			max_ladder_type= bn_int_get(header.maxtype);
103			if (d2ladderlist_create(max_ladder_type)<0) {
104			eventlog(eventlog_level_error,__FUNCTION__,"error create ladder list");
105			fclose(fp);
106			return -1;
107			}
108			temp= max_ladder_type * sizeof(*ladderheader);
109			ladderheader=xmalloc(temp);
110			if (fread(ladderheader,1,temp,fp)!=temp) {
111			eventlog(eventlog_level_error,__FUNCTION__,"error read ladder file");
112			xfree(ladderheader);
113			fclose(fp);
114			return -1;
115			}
116			for (i=0, count=0; i< max_ladder_type ; i++) {
117			type=bn_int_get(ladderheader[i].type);
118			number=bn_int_get(ladderheader[i].number);
119			if (d2ladder_create(type,number)<0) {
120			eventlog(eventlog_level_error,__FUNCTION__,"error create ladder %d",type);
121			continue;
122			}
123			fseek(fp,bn_int_get(ladderheader[i].offset),SEEK_SET);
124			temp=number * sizeof(*ladderinfo);
125			ladderinfo=xmalloc(temp);
126			if (fread(ladderinfo,1,temp,fp)!=temp) {
127			eventlog(eventlog_level_error,__FUNCTION__,"error read ladder file");
128			xfree(ladderinfo);
129			continue;
130			}
131			for (n=0; n< number; n++) {
132			d2ladder_append_ladder(type,ladderinfo+n);
133			}
134			xfree(ladderinfo);
135			if (number) count++;
136			}
137			xfree(ladderheader);
138			fclose(fp);
139			eventlog(eventlog_level_info,__FUNCTION__,"ladder file loaded successfully (%d types %d maxtype)",count,max_ladder_type);
140			return 0;
141			}
142
143			static int d2ladderlist_create(unsigned int maxtype)
144			{
145			ladder_data=xmalloc(maxtype * sizeof(*ladder_data));
146			memset(ladder_data,0, maxtype * sizeof(*ladder_data));
147			return 0;
148			}
149
150			extern int d2ladder_refresh(void)
151			{
152			d2ladder_destroy();
153			return d2ladder_readladder();
154			}
155
156			static int d2ladder_create(unsigned int type, unsigned int len)
157			{
158			if (type>max_ladder_type) {
159			eventlog(eventlog_level_error,__FUNCTION__,"ladder type %d exceed max ladder type %d",type,max_ladder_type);
160			return -1;
161			}
162			ladder_data[type].info=xmalloc(sizeof(t_d2cs_client_ladderinfo) * len);
163			ladder_data[type].len=len;
164			ladder_data[type].type=type;
165			ladder_data[type].curr_len=0;
166			return 0;
167			}
168
169			static int d2ladder_append_ladder(unsigned int type, t_d2ladderfile_ladderinfo * info)
170			{
171			t_d2cs_client_ladderinfo * ladderinfo;
172			unsigned short ladderstatus;
173			unsigned short status;
174			unsigned char class;
175
176			if (!info) {
177			eventlog(eventlog_level_error,__FUNCTION__,"got NULL info");
178			return -1;
179			}
180			if (type > max_ladder_type) {
181			eventlog(eventlog_level_error,__FUNCTION__,"ladder type %d exceed max ladder type %d",type,max_ladder_type);
182			return -1;
183			}
184			if (!ladder_data[type].info) {
185			eventlog(eventlog_level_error,__FUNCTION__,"ladder data info not initialized");
186			return -1;
187			}
188			if (ladder_data[type].curr_len >= ladder_data[type].len) {
189			eventlog(eventlog_level_error,__FUNCTION__,"ladder data overflow %d > %d", ladder_data[type].curr_len, ladder_data[type].len);
190			return -1;
191			}
192			status = bn_short_get(info->status);
193			class = bn_byte_get(info->class);
194			ladderstatus = (status & LADDERSTATUS_FLAG_DIFFICULTY);
195			if (charstatus_get_hardcore(status)) {
196			ladderstatus \|= LADDERSTATUS_FLAG_HARDCORE;
197			if (charstatus_get_dead(status)) {
198			ladderstatus \|= LADDERSTATUS_FLAG_DEAD;
199			}
200			}
201			if (charstatus_get_expansion(status)) {
202			ladderstatus \|= LADDERSTATUS_FLAG_EXPANSION;
203			ladderstatus \|= min(class,D2CHAR_EXP_CLASS_MAX);
204			} else {
205			ladderstatus \|= min(class,D2CHAR_CLASS_MAX);
206			}
207			ladderinfo=ladder_data[type].info+ladder_data[type].curr_len;
208			bn_int_set(&ladderinfo->explow, bn_int_get(info->experience));
209			bn_int_set(&ladderinfo->exphigh,0);
210			bn_short_set(&ladderinfo->status,ladderstatus);
211			bn_byte_set(&ladderinfo->level, bn_int_get(info->level));
212			bn_byte_set(&ladderinfo->u1, 0);
213			strncpy(ladderinfo->charname, info->charname, MAX_CHARNAME_LEN);
214			ladder_data[type].curr_len++;
215			return 0;
216			}
217
218			extern int d2ladder_destroy(void)
219			{
220			unsigned int i;
221
222			if (ladder_data) {
223			for (i=0; i< max_ladder_type; i++) {
224			if (ladder_data[i].info) {
225			xfree(ladder_data[i].info);
226			ladder_data[i].info=NULL;
227			}
228			}
229			xfree(ladder_data);
230			ladder_data=NULL;
231			}
232			max_ladder_type=0;
233			return 0;
234			}
235
236			extern int d2ladder_get_ladder(unsigned int * from, unsigned int * count, unsigned int type,
237			t_d2cs_client_ladderinfo const * * info)
238			{
239			t_d2ladder * ladder;
240
241			if (!ladder_data) return -1;
242			ladder=ladder_data+type;
243			if (!ladder->curr_len \|\| !ladder->info) {
244			eventlog(eventlog_level_warn,__FUNCTION__,"ladder type %d not found",type);
245			return -1;
246			}
247			if (ladder->type != type) {
248			eventlog(eventlog_level_error,__FUNCTION__,"got bad ladder data");
249			return -1;
250			}
251			if (ladder->curr_len < *count) {
252			*from = 0;
253			*count=ladder->curr_len;
254			} else if (from + count> ladder->curr_len) {
255			from= ladder->curr_len - count;
256			}
257			info = ladder->info+ from;
258			return 0;
259			}
260
261			extern int d2ladder_find_character_pos(unsigned int type, char const * charname)
262			{
263			unsigned int i;
264			t_d2ladder * ladder;
265
266			if (!ladder_data) return -1;
267			ladder=ladder_data+type;
268			if (!ladder->curr_len \|\| !ladder->info) {
269			eventlog(eventlog_level_warn,__FUNCTION__,"ladder type %d not found",type);
270			return -1;
271			}
272			if (ladder->type != type) {
273			eventlog(eventlog_level_error,__FUNCTION__,"got bad ladder data");
274			return -1;
275			}
276			for (i=0; i< ladder->curr_len; i++) {
277			if (!strcasecmp(ladder->info[i].charname,charname)) return i;
278			}
279			return -1;
280			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1