server/server/resurrection.c

/*
 * static char *rcsid_resurrection_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
*/

/*  the contents of this file were create solely by peterm@soda.berkeley.edu
    all of the above disclaimers apply.  */

#include <global.h>
#ifndef __CEXTRACT__
#include <sproto.h>
#endif
#include <spells.h>
#include <errno.h>
#ifdef sequent
/* stoopid sequent includes don't do this like they should */
extern char * sys_errlist[];
extern int sys_nerr;
#endif
extern char **classname;
extern object *objects;


/*  name of the person to resurrect and which spell was used
 * to resurrect  
 */
static int resurrect_player(object *op,char *playername,object *spell)
{
    FILE *deadplayer,*liveplayer;

    char oldname[MAX_BUF];
    char newname[MAX_BUF];
    char path[MAX_BUF];
    char buf[MAX_BUF];
    char buf2[MAX_BUF];
    const char *race=NULL;
    sint64 exp;
    int Con;


    /* reincarnation, which changes the race */
    if (spell->race) {
        treasurelist *tl = find_treasurelist(spell->race);
        treasure *t;
        int value;
        if (!tl) {
            LOG(llevError,"resurrect_player: race set to %s, but no treasurelist of that name!\n", spell->race);
            return 0;
        }
        value = RANDOM() % tl->total_chance;
        for (t=tl->items; t; t=t->next) {
            value -= t->chance;
            if (value<0) break;
        }
        if (!t) {
            LOG(llevError,"resurrect_player: got null treasure from treasurelist %s!\n", spell->race);
            return 0;
        }
        race = t->item->name;
    }

    /*  set up our paths/strings...  */
    sprintf(path,"%s/%s/%s/%s",settings.localdir,settings.playerdir,playername,
          playername);

    strcpy(newname,path);
    strcat(newname,".pl");

    strcpy(oldname,newname);
    strcat(oldname,".dead");

    if(! (deadplayer=fopen(oldname,"r"))) {
        new_draw_info_format(NDI_UNIQUE, 0, op,
             "The soul of %s cannot be reached.",playername);
        return 0;
    }

    if(!access(newname,0)) {
        new_draw_info_format(NDI_UNIQUE, 0, op,
             "The soul of %s has already been reborn!",playername);
        fclose(deadplayer);
        return 0;
    }

    if(! (liveplayer=fopen(newname,"w"))) {
        new_draw_info_format(NDI_UNIQUE, 0, op,
                "The soul of %s cannot be re-embodied at the moment.",playername);
        LOG(llevError,"Cannot write player in resurrect_player!\n");
        fclose(deadplayer);
        return 0;
    }

    while (!feof(deadplayer)) {
        fgets(buf,255,deadplayer);
        sscanf(buf,"%s",buf2);
        if( ! (strcmp(buf2,"exp"))) {
#ifndef WIN32
            sscanf(buf,"%s %lld",buf2,&exp);
#else
            sscanf(buf,"%s %I64d",buf2,&exp);
#endif
            if (spell->stats.exp) {
                exp-=exp/spell->stats.exp;
#ifndef WIN32
                sprintf(buf,"exp %lld\n",exp);
#else
                sprintf(buf,"exp %I64d\n",exp);
#endif
            }
        }
        if(! (strcmp(buf2,"Con"))) {
            sscanf(buf,"%s %d",buf2,&Con);
            Con -= spell->stats.Con;
            if (Con < 1) Con = 1;
            sprintf(buf,"Con %d\n",Con);
        }
        if(race && !strcmp(buf2,"race")) {
            sprintf(buf,"race %s\n",race);
        }
        fputs(buf,liveplayer);
    }
    fclose(liveplayer);
    fclose(deadplayer);
    unlink(oldname);
    new_draw_info_format(NDI_UNIQUE, 0, op,
        "%s lives again!",playername);

    return 1;
}


/* raise_dead by peterm and mehlhaff@soda.berkeley.edu
 * op  --  who is doing the resurrecting
 * spell - spell object 
 * dir  --  direction the spell is cast
 * corpseobj - corpse to raise - can be null, in which case this function will find it
 */
int cast_raise_dead_spell(object *op, object *caster, object *spell, int dir, const char *arg)
{
    object *temp, *newob;
    char name_to_resurrect[MAX_BUF];
    int leveldead=25, mflags, clevel;
    sint16 sx, sy;
    mapstruct *m;

    clevel = caster_level(caster, spell);

    if (spell->last_heal) {
        if (!arg) {
            new_draw_info_format(NDI_UNIQUE, 0,op,"Cast %s on who?", spell->name);
            return 0;
        }
        strcpy(name_to_resurrect, arg);
        temp = NULL;
    } else {
        sx = op->x+freearr_x[dir];
        sy = op->y+freearr_y[dir];
        m = op->map;
        mflags = get_map_flags(m, &m, sx, sy, &sx, &sy);
        if (mflags & P_OUT_OF_MAP)
            temp=NULL;
        else {
            /*  First we need to find a corpse, if any.  */
            /* If no object, temp will be set to NULL */
            for(temp=get_map_ob(m, sx, sy); temp!=NULL; temp=temp->above)
                /* If it is corpse, this must be what we want to raise */
                if(temp->type == CORPSE)
                    break;
        }

        if(temp == NULL) {
            new_draw_info(NDI_UNIQUE, 0,op, "You need a body for this spell.");
            return 0;
        }
        strcpy(name_to_resurrect, temp->name );
    }

     /* no matter what, we fry the corpse.  */
    if( temp && temp->map){
        /* replace corpse object with a burning object */
        newob = arch_to_object(find_archetype("burnout"));
        if(newob != NULL){
            newob->x = temp->x;
            newob->y = temp->y;
            insert_ob_in_map( newob, temp->map, op,0);
        }
        leveldead=temp->level;
        remove_ob(temp);
        free_object(temp);
    }

    if(resurrection_fails(clevel,leveldead)) {
        if (spell->randomitems) {
            treasure *t;

            for (t=spell->randomitems->items; t; t=t->next) {
                summon_hostile_monsters(op, t->nrof, t->item->name);
            }

        }
        return 1;

    } else {
            return resurrect_player(op,name_to_resurrect,spell);
    }

    return 1;
}


int resurrection_fails(int levelcaster,int leveldead)
{
    int chance=9;
    /*  scheme:  equal in level, 50% success.
     * +5 % for each level below, -5% for each level above.
     * minimum 20%
     */
    chance+=levelcaster-leveldead;
    if(chance<4) chance=4;
    if(chance>rndm(0, 19)) return 0;  /* resurrection succeeds */
    return 1;
}

void dead_player(object *op)
{
    char filename[MAX_BUF];
    char newname[MAX_BUF];
    char path[MAX_BUF];

    /*  set up our paths/strings...  */
    sprintf(path,"%s/%s/%s/%s",settings.localdir,settings.playerdir,op->name,
          op->name);

    strcpy(filename,path);
    strcat(filename,".pl");
    strcpy(newname,filename);
    strcat(newname,".dead");

    if(rename(filename,newname) != 0) {
        LOG(llevError, "Cannot rename dead player's file %s into %s: %s\n", filename, newname, strerror_local(errno));
    }
}


void dead_character(const char *name) {
    char buf[MAX_BUF];
    char buf2[MAX_BUF];

    sprintf(buf,"%s/%s/%s/%s.pl",settings.localdir,settings.playerdir,name, name);
    /*  peterm:  create a .dead filename....  ***.pl.dead  */
    strcpy(buf2,buf);
    strcat(buf,".dead");
    if(rename(buf2,buf)== -1){
        LOG(llevError, "Cannot rename dead player's file %s into %s: %s\n", buf2, buf, strerror_local(errno));
    }
}


int dead_player_exists(const char *name) {
    char buf[MAX_BUF];

    sprintf(buf,"%s/%s/%s/%s",settings.localdir,settings.playerdir,name, name);
    strcat(buf,".pl.dead");
    return !(access(buf,0));
}


Revision:	1.2
Committed:	Sun Aug 13 17:16:04 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.
#	Content
1	/*
2	* static char *rcsid_resurrection_c =
3	* "$Id$";
4	*/
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	/* the contents of this file were create solely by peterm@soda.berkeley.edu
30	all of the above disclaimers apply. */
31
32	#include <global.h>
33	#ifndef __CEXTRACT__
34	#include <sproto.h>
35	#endif
36	#include <spells.h>
37	#include <errno.h>
38	#ifdef sequent
39	/* stoopid sequent includes don't do this like they should */
40	extern char * sys_errlist[];
41	extern int sys_nerr;
42	#endif
43	extern char **classname;
44	extern object *objects;
45
46
47
48	/* name of the person to resurrect and which spell was used
49	* to resurrect
50	*/
51	static int resurrect_player(object op,char playername,object *spell)
52	{
53	FILE deadplayer,liveplayer;
54
55	char oldname[MAX_BUF];
56	char newname[MAX_BUF];
57	char path[MAX_BUF];
58	char buf[MAX_BUF];
59	char buf2[MAX_BUF];
60	const char *race=NULL;
61	sint64 exp;
62	int Con;
63
64
65	/* reincarnation, which changes the race */
66	if (spell->race) {
67	treasurelist *tl = find_treasurelist(spell->race);
68	treasure *t;
69	int value;
70	if (!tl) {
71	LOG(llevError,"resurrect_player: race set to %s, but no treasurelist of that name!\n", spell->race);
72	return 0;
73	}
74	value = RANDOM() % tl->total_chance;
75	for (t=tl->items; t; t=t->next) {
76	value -= t->chance;
77	if (value<0) break;
78	}
79	if (!t) {
80	LOG(llevError,"resurrect_player: got null treasure from treasurelist %s!\n", spell->race);
81	return 0;
82	}
83	race = t->item->name;
84	}
85
86	/* set up our paths/strings... */
87	sprintf(path,"%s/%s/%s/%s",settings.localdir,settings.playerdir,playername,
88	playername);
89
90	strcpy(newname,path);
91	strcat(newname,".pl");
92
93	strcpy(oldname,newname);
94	strcat(oldname,".dead");
95
96	if(! (deadplayer=fopen(oldname,"r"))) {
97	new_draw_info_format(NDI_UNIQUE, 0, op,
98	"The soul of %s cannot be reached.",playername);
99	return 0;
100	}
101
102	if(!access(newname,0)) {
103	new_draw_info_format(NDI_UNIQUE, 0, op,
104	"The soul of %s has already been reborn!",playername);
105	fclose(deadplayer);
106	return 0;
107	}
108
109	if(! (liveplayer=fopen(newname,"w"))) {
110	new_draw_info_format(NDI_UNIQUE, 0, op,
111	"The soul of %s cannot be re-embodied at the moment.",playername);
112	LOG(llevError,"Cannot write player in resurrect_player!\n");
113	fclose(deadplayer);
114	return 0;
115	}
116
117	while (!feof(deadplayer)) {
118	fgets(buf,255,deadplayer);
119	sscanf(buf,"%s",buf2);
120	if( ! (strcmp(buf2,"exp"))) {
121	#ifndef WIN32
122	sscanf(buf,"%s %lld",buf2,&exp);
123	#else
124	sscanf(buf,"%s %I64d",buf2,&exp);
125	#endif
126	if (spell->stats.exp) {
127	exp-=exp/spell->stats.exp;
128	#ifndef WIN32
129	sprintf(buf,"exp %lld\n",exp);
130	#else
131	sprintf(buf,"exp %I64d\n",exp);
132	#endif
133	}
134	}
135	if(! (strcmp(buf2,"Con"))) {
136	sscanf(buf,"%s %d",buf2,&Con);
137	Con -= spell->stats.Con;
138	if (Con < 1) Con = 1;
139	sprintf(buf,"Con %d\n",Con);
140	}
141	if(race && !strcmp(buf2,"race")) {
142	sprintf(buf,"race %s\n",race);
143	}
144	fputs(buf,liveplayer);
145	}
146	fclose(liveplayer);
147	fclose(deadplayer);
148	unlink(oldname);
149	new_draw_info_format(NDI_UNIQUE, 0, op,
150	"%s lives again!",playername);
151
152	return 1;
153	}
154
155
156	/* raise_dead by peterm and mehlhaff@soda.berkeley.edu
157	* op -- who is doing the resurrecting
158	* spell - spell object
159	* dir -- direction the spell is cast
160	* corpseobj - corpse to raise - can be null, in which case this function will find it
161	*/
162	int cast_raise_dead_spell(object op, object caster, object spell, int dir, const char arg)
163	{
164	object temp, newob;
165	char name_to_resurrect[MAX_BUF];
166	int leveldead=25, mflags, clevel;
167	sint16 sx, sy;
168	mapstruct *m;
169
170	clevel = caster_level(caster, spell);
171
172	if (spell->last_heal) {
173	if (!arg) {
174	new_draw_info_format(NDI_UNIQUE, 0,op,"Cast %s on who?", spell->name);
175	return 0;
176	}
177	strcpy(name_to_resurrect, arg);
178	temp = NULL;
179	} else {
180	sx = op->x+freearr_x[dir];
181	sy = op->y+freearr_y[dir];
182	m = op->map;
183	mflags = get_map_flags(m, &m, sx, sy, &sx, &sy);
184	if (mflags & P_OUT_OF_MAP)
185	temp=NULL;
186	else {
187	/* First we need to find a corpse, if any. */
188	/* If no object, temp will be set to NULL */
189	for(temp=get_map_ob(m, sx, sy); temp!=NULL; temp=temp->above)
190	/* If it is corpse, this must be what we want to raise */
191	if(temp->type == CORPSE)
192	break;
193	}
194
195	if(temp == NULL) {
196	new_draw_info(NDI_UNIQUE, 0,op, "You need a body for this spell.");
197	return 0;
198	}
199	strcpy(name_to_resurrect, temp->name );
200	}
201
202	/* no matter what, we fry the corpse. */
203	if( temp && temp->map){
204	/* replace corpse object with a burning object */
205	newob = arch_to_object(find_archetype("burnout"));
206	if(newob != NULL){
207	newob->x = temp->x;
208	newob->y = temp->y;
209	insert_ob_in_map( newob, temp->map, op,0);
210	}
211	leveldead=temp->level;
212	remove_ob(temp);
213	free_object(temp);
214	}
215
216	if(resurrection_fails(clevel,leveldead)) {
217	if (spell->randomitems) {
218	treasure *t;
219
220	for (t=spell->randomitems->items; t; t=t->next) {
221	summon_hostile_monsters(op, t->nrof, t->item->name);
222	}
223
224	}
225	return 1;
226
227	} else {
228	return resurrect_player(op,name_to_resurrect,spell);
229	}
230
231	return 1;
232	}
233
234
235	int resurrection_fails(int levelcaster,int leveldead)
236	{
237	int chance=9;
238	/* scheme: equal in level, 50% success.
239	* +5 % for each level below, -5% for each level above.
240	* minimum 20%
241	*/
242	chance+=levelcaster-leveldead;
243	if(chance<4) chance=4;
244	if(chance>rndm(0, 19)) return 0; /* resurrection succeeds */
245	return 1;
246	}
247
248	void dead_player(object *op)
249	{
250	char filename[MAX_BUF];
251	char newname[MAX_BUF];
252	char path[MAX_BUF];
253
254	/* set up our paths/strings... */
255	sprintf(path,"%s/%s/%s/%s",settings.localdir,settings.playerdir,op->name,
256	op->name);
257
258	strcpy(filename,path);
259	strcat(filename,".pl");
260	strcpy(newname,filename);
261	strcat(newname,".dead");
262
263	if(rename(filename,newname) != 0) {
264	LOG(llevError, "Cannot rename dead player's file %s into %s: %s\n", filename, newname, strerror_local(errno));
265	}
266	}
267
268
269
270	void dead_character(const char *name) {
271	char buf[MAX_BUF];
272	char buf2[MAX_BUF];
273
274	sprintf(buf,"%s/%s/%s/%s.pl",settings.localdir,settings.playerdir,name, name);
275	/* peterm: create a .dead filename.... **.pl.dead /
276	strcpy(buf2,buf);
277	strcat(buf,".dead");
278	if(rename(buf2,buf)== -1){
279	LOG(llevError, "Cannot rename dead player's file %s into %s: %s\n", buf2, buf, strerror_local(errno));
280	}
281	}
282
283
284	int dead_player_exists(const char *name) {
285	char buf[MAX_BUF];
286
287	sprintf(buf,"%s/%s/%s/%s",settings.localdir,settings.playerdir,name, name);
288	strcat(buf,".pl.dead");
289	return !(access(buf,0));
290	}
291
292