server/common/exp.C

/*
 * static char *rcsid_arch_c =
 *   "$Id: exp.C,v 1.3 2006-08-30 16:30:36 root Exp $";
 */

/*
    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 <stdio.h>
#include <global.h>

sint64 *levels;

float exp_att_mult[NROFATTACKS+2] = {
        0.0,                            /* AT_PHYSICAL  */
        0.0,                            /* AT_MAGIC     */
        0.0,                            /* AT_FIRE      */
        0.0,                            /* AT_ELECTRICITY */
        0.0,                            /* AT_COLD      */
        0.0,                            /* AT_WATER     *//*AT_CONFUSION!*/
        0.4,                            /* AT_ACID      */
        1.5,                            /* AT_DRAIN     */
        0.0,                            /* AT_WEAPONMAGIC */
        0.1,                            /* AT_GHOSTHIT  */
        0.3,                            /* AT_POISON    */
        0.2,                            /* AT_DISEASE   */
        0.3,                            /* AT_PARALYZE  */
        0.0,                            /* AT_TURN_UNDEAD */
        0.0,                            /* AT_FEAR      */
        0.0,                            /* AT_CANCELLATION */
        0.0,                            /* AT_DEPLETE */
        0.0,                            /* AT_DEATH */
        0.0,                            /* AT_CHAOS */
        0.0                             /* AT_COUNTERSPELL */
};

float exp_prot_mult[NROFATTACKS+2] = {
        0.4,                            /* AT_PHYSICAL  */
        0.5,                            /* AT_MAGIC     */
        0.1,                            /* AT_FIRE      */
        0.1,                            /* AT_ELECTRICITY */
        0.1,                            /* AT_COLD      */
        0.1,                            /* AT_WATER     */
        0.1,                            /* AT_ACID      */
        0.1,                            /* AT_DRAIN     */
        0.1,                            /* AT_WEAPONMAGIC */
        0.1,                            /* AT_GHOSTHIT  */
        0.1,                            /* AT_POISON    */
        0.1,                            /* AT_DISEASE   */
        0.1,                            /* AT_PARALYZE  */
        0.1,                            /* AT_TURN_UNDEAD */
        0.1,                            /* AT_FEAR      */
        0.0,                            /* AT_CANCELLATION */
        0.0,                            /* AT_DEPLETE */
        0.0,                            /* AT_DEATH */
        0.0,                            /* AT_CHAOS */
        0.0                             /* AT_COUNTERSPELL */

};

/*
 * new_exp() is an alternative way to calculate experience based
 * on the ability of a monster.
 * It's far from perfect, and doesn't consider everything which
 * can be considered, thus it's only used in debugging.
 * this is only used with one of the dumpflags,
 * and not anyplace in the code.
 */
        
int new_exp(const object *ob) {
  double        att_mult, prot_mult, spec_mult;
  double        exp;
  int           i;
  long          mask = 1;

  att_mult = prot_mult =spec_mult = 1.0;
  for(i=0;i<NROFATTACKS;i++) {
    mask = 1<<i;
    att_mult += (exp_att_mult[i] * ((ob->attacktype&mask) != 0));
    /* We multiply & then divide to prevent roundoffs on the floats.
     * the doubling is to take into account the table and resistances
     * are lower than they once were.
     */
    prot_mult += (exp_prot_mult[i] * 200*ob->resist[i]) / 100.0;
  }
  spec_mult +=  (0.3*(QUERY_FLAG(ob,FLAG_SEE_INVISIBLE)!= 0)) +
                (0.5*(QUERY_FLAG(ob,FLAG_SPLITTING)!= 0))+
                (0.3*(QUERY_FLAG(ob,FLAG_HITBACK)!= 0)) + 
                (0.1*(QUERY_FLAG(ob,FLAG_REFL_MISSILE)!= 0)) +
                (0.3*(QUERY_FLAG(ob,FLAG_REFL_SPELL)!= 0)) +
                (1.0*(QUERY_FLAG(ob,FLAG_NO_MAGIC)!= 0)) +
                (0.1*(QUERY_FLAG(ob,FLAG_PICK_UP)!= 0)) + 
                (0.1*(QUERY_FLAG(ob,FLAG_USE_SCROLL)!= 0)) +
                (0.2*(QUERY_FLAG(ob,FLAG_USE_RANGE)!= 0)) +
                (0.1*(QUERY_FLAG(ob,FLAG_USE_BOW)!= 0));

  exp = (ob->stats.maxhp<5) ? 5 : ob->stats.maxhp;
  exp *= (QUERY_FLAG(ob,FLAG_CAST_SPELL) && has_ability(ob)) 
         ? (40+(ob->stats.maxsp>80?80:ob->stats.maxsp))/40 : 1;
  exp *= (80.0/(70.0+ob->stats.wc)) * (80.0/(70.0+ob->stats.ac)) * (50.0+ob->stats.dam)/50.0;
  exp *= att_mult * prot_mult * spec_mult;
  exp *= 2.0/(2.0-((FABS(ob->speed)<0.95)?FABS(ob->speed):0.95));
  exp *= (20.0+ob->stats.Con)/20.0;
  if (QUERY_FLAG(ob, FLAG_STAND_STILL))
    exp /= 2;

  return (int) exp;
}

/*
 * Returns true if the monster specified has any innate abilities.
 */

int has_ability(const object *ob) {
    object *tmp;

    for(tmp=ob->inv;tmp!=NULL;tmp=tmp->below)
        if(tmp->type==SPELL||tmp->type==SPELLBOOK) 
            return true;
    return false;
}

/* This loads the experience table from the exp_table
 * file.  This tends to exit on any errors, since it
 * populates the table as it goes along, so if there
 * are errors, the table is likely in an inconsistent
 * state.
 */
void init_experience(void)
{
    char buf[MAX_BUF], *cp;
    int lastlevel=0, comp;
    sint64 lastexp=-1, tmpexp;
    FILE *fp;
    

    sprintf(buf,"%s/exp_table",settings.confdir);

    if ((fp = open_and_uncompress(buf, 0, &comp)) == NULL) {
        return;
    }
    while (fgets(buf, MAX_BUF-1, fp) != NULL) {
        if (buf[0] == '#') continue;

        /* eliminate newline */
        if ((cp=strrchr(buf,'\n'))!=NULL) *cp='\0';

        /* Skip over empty lines */
        if (buf[0] == 0) continue;
        cp = buf;
        while (isspace(*cp) && *cp!=0) cp++;
        if (!strncasecmp(cp, "max_level",9)) {
            if (settings.max_level) {
                LOG(llevDebug, "Got more than one max_level value from exp_table file?\n");
                free(levels);
            }
            settings.max_level = atoi(cp+9);
            if (!settings.max_level) {
                LOG(llevDebug, "Got invalid max_level from exp_table file? %s\n", buf);
            } else {
                levels = (sint64 *) calloc(settings.max_level +1, sizeof(sint64));
            }
        }
        while (isdigit(*cp) && *cp!=0) {
            if (!settings.max_level) {
                LOG(llevError, "max_level is not set in exp_table file.  Did you remember to update it?\n");
                exit(1);
            }

            tmpexp = atoll(cp);
            /* Do some sanity checking - if value is bogus, just exit because
             * the table otherwise is probably in an inconsistent state
             */
            if (tmpexp <= lastexp) {
#ifndef WIN32
                LOG(llevError,"Experience for level %d is lower than previous level (%lld <= %lld)\n",
                    lastlevel + 1, tmpexp, lastexp);
#else
                LOG(llevError,"Experience for level %d is lower than previous level (%I64d <= %I64d)\n",
                    lastlevel + 1, tmpexp, lastexp);
#endif
                exit(1);
            }
            lastlevel++;
            if (lastlevel > settings.max_level) {
                LOG(llevError,"Too many levels specified in table (%d > %d)\n", 
                    lastlevel, settings.max_level);
                exit(1);
            }
            levels[lastlevel] = tmpexp;
            lastexp = tmpexp;
            /* First, skip over the number we just processed. Then skip over
             * any spaces, commas, etc.
             */
            while (isdigit(*cp) && *cp!=0) cp++;
            while (!isdigit(*cp) && *cp!=0) cp++;
        }
    }
    close_and_delete(fp, comp);
    if (lastlevel != settings.max_level && lastlevel != 0) {
        LOG(llevError,"Warning: exp_table does not have %d entries (%d)\n",
            settings.max_level, lastlevel);
        exit(1);
    }
}

/* Dump the table - useful in terms of debugging to make sure the
 * format of the exp_table is correct.
 */

void dump_experience()
{
    int i;

    for (i=1; i<= settings.max_level; i++) {
        fprintf(logfile,"%4d %20lld\n", i, (long long)levels[i]);
    }
    exit(0);
}
Revision:	1.4
Committed:	Sun Sep 3 00:18:39 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+2 -2 lines
Log Message:	THIS CODE WILL NOT COMPILE use the STABLE tag instead. - major changes in object lifetime and memory management - replaced manual refcounting by shstr class - removed quest system - many optimisations - major changes
#	User	Rev	Content
1	elmex	1.1	/*
2			* static char *rcsid_arch_c =
3	root	1.4	* "$Id: exp.C,v 1.3 2006-08-30 16:30:36 root Exp $";
4	elmex	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			#include <stdio.h>
30			#include <global.h>
31
32			sint64 *levels;
33
34			float exp_att_mult[NROFATTACKS+2] = {
35	root	1.2	0.0, /* AT_PHYSICAL */
36			0.0, /* AT_MAGIC */
37			0.0, /* AT_FIRE */
38			0.0, /* AT_ELECTRICITY */
39			0.0, /* AT_COLD */
40			0.0, /* AT_WATER //AT_CONFUSION!*/
41			0.4, /* AT_ACID */
42			1.5, /* AT_DRAIN */
43			0.0, /* AT_WEAPONMAGIC */
44			0.1, /* AT_GHOSTHIT */
45			0.3, /* AT_POISON */
46			0.2, /* AT_DISEASE */
47			0.3, /* AT_PARALYZE */
48			0.0, /* AT_TURN_UNDEAD */
49			0.0, /* AT_FEAR */
50			0.0, /* AT_CANCELLATION */
51			0.0, /* AT_DEPLETE */
52			0.0, /* AT_DEATH */
53			0.0, /* AT_CHAOS */
54			0.0 /* AT_COUNTERSPELL */
55	elmex	1.1	};
56
57			float exp_prot_mult[NROFATTACKS+2] = {
58	root	1.2	0.4, /* AT_PHYSICAL */
59			0.5, /* AT_MAGIC */
60			0.1, /* AT_FIRE */
61			0.1, /* AT_ELECTRICITY */
62			0.1, /* AT_COLD */
63			0.1, /* AT_WATER */
64			0.1, /* AT_ACID */
65			0.1, /* AT_DRAIN */
66			0.1, /* AT_WEAPONMAGIC */
67			0.1, /* AT_GHOSTHIT */
68			0.1, /* AT_POISON */
69			0.1, /* AT_DISEASE */
70			0.1, /* AT_PARALYZE */
71			0.1, /* AT_TURN_UNDEAD */
72			0.1, /* AT_FEAR */
73			0.0, /* AT_CANCELLATION */
74			0.0, /* AT_DEPLETE */
75			0.0, /* AT_DEATH */
76			0.0, /* AT_CHAOS */
77			0.0 /* AT_COUNTERSPELL */
78	elmex	1.1
79			};
80
81			/*
82			* new_exp() is an alternative way to calculate experience based
83			* on the ability of a monster.
84			* It's far from perfect, and doesn't consider everything which
85			* can be considered, thus it's only used in debugging.
86			* this is only used with one of the dumpflags,
87			* and not anyplace in the code.
88			*/
89	root	1.2
90	elmex	1.1	int new_exp(const object *ob) {
91			double att_mult, prot_mult, spec_mult;
92			double exp;
93			int i;
94			long mask = 1;
95
96			att_mult = prot_mult =spec_mult = 1.0;
97			for(i=0;i<NROFATTACKS;i++) {
98			mask = 1<<i;
99	root	1.3	att_mult += (exp_att_mult[i] * ((ob->attacktype&mask) != 0));
100	elmex	1.1	/* We multiply & then divide to prevent roundoffs on the floats.
101			* the doubling is to take into account the table and resistances
102			* are lower than they once were.
103			*/
104			prot_mult += (exp_prot_mult[i] * 200*ob->resist[i]) / 100.0;
105			}
106	root	1.3	spec_mult += (0.3*(QUERY_FLAG(ob,FLAG_SEE_INVISIBLE)!= 0)) +
107			(0.5*(QUERY_FLAG(ob,FLAG_SPLITTING)!= 0))+
108			(0.3*(QUERY_FLAG(ob,FLAG_HITBACK)!= 0)) +
109			(0.1*(QUERY_FLAG(ob,FLAG_REFL_MISSILE)!= 0)) +
110			(0.3*(QUERY_FLAG(ob,FLAG_REFL_SPELL)!= 0)) +
111			(1.0*(QUERY_FLAG(ob,FLAG_NO_MAGIC)!= 0)) +
112			(0.1*(QUERY_FLAG(ob,FLAG_PICK_UP)!= 0)) +
113			(0.1*(QUERY_FLAG(ob,FLAG_USE_SCROLL)!= 0)) +
114			(0.2*(QUERY_FLAG(ob,FLAG_USE_RANGE)!= 0)) +
115			(0.1*(QUERY_FLAG(ob,FLAG_USE_BOW)!= 0));
116	elmex	1.1
117			exp = (ob->stats.maxhp<5) ? 5 : ob->stats.maxhp;
118			exp *= (QUERY_FLAG(ob,FLAG_CAST_SPELL) && has_ability(ob))
119			? (40+(ob->stats.maxsp>80?80:ob->stats.maxsp))/40 : 1;
120			exp = (80.0/(70.0+ob->stats.wc)) (80.0/(70.0+ob->stats.ac)) * (50.0+ob->stats.dam)/50.0;
121			exp = att_mult prot_mult * spec_mult;
122			exp *= 2.0/(2.0-((FABS(ob->speed)<0.95)?FABS(ob->speed):0.95));
123			exp *= (20.0+ob->stats.Con)/20.0;
124			if (QUERY_FLAG(ob, FLAG_STAND_STILL))
125			exp /= 2;
126
127			return (int) exp;
128			}
129
130			/*
131			* Returns true if the monster specified has any innate abilities.
132			*/
133
134			int has_ability(const object *ob) {
135			object *tmp;
136
137			for(tmp=ob->inv;tmp!=NULL;tmp=tmp->below)
138	root	1.2	if(tmp->type==SPELL\|\|tmp->type==SPELLBOOK)
139	root	1.3	return true;
140			return false;
141	elmex	1.1	}
142
143			/* This loads the experience table from the exp_table
144			* file. This tends to exit on any errors, since it
145			* populates the table as it goes along, so if there
146			* are errors, the table is likely in an inconsistent
147			* state.
148			*/
149			void init_experience(void)
150			{
151			char buf[MAX_BUF], *cp;
152			int lastlevel=0, comp;
153			sint64 lastexp=-1, tmpexp;
154			FILE *fp;
155
156
157			sprintf(buf,"%s/exp_table",settings.confdir);
158
159			if ((fp = open_and_uncompress(buf, 0, &comp)) == NULL) {
160			return;
161			}
162			while (fgets(buf, MAX_BUF-1, fp) != NULL) {
163	root	1.2	if (buf[0] == '#') continue;
164	elmex	1.1
165	root	1.2	/* eliminate newline */
166			if ((cp=strrchr(buf,'\n'))!=NULL) *cp='\0';
167	elmex	1.1
168	root	1.2	/* Skip over empty lines */
169			if (buf[0] == 0) continue;
170			cp = buf;
171			while (isspace(cp) && cp!=0) cp++;
172			if (!strncasecmp(cp, "max_level",9)) {
173			if (settings.max_level) {
174			LOG(llevDebug, "Got more than one max_level value from exp_table file?\n");
175			free(levels);
176			}
177			settings.max_level = atoi(cp+9);
178			if (!settings.max_level) {
179			LOG(llevDebug, "Got invalid max_level from exp_table file? %s\n", buf);
180			} else {
181			levels = (sint64 *) calloc(settings.max_level +1, sizeof(sint64));
182			}
183			}
184			while (isdigit(cp) && cp!=0) {
185			if (!settings.max_level) {
186			LOG(llevError, "max_level is not set in exp_table file. Did you remember to update it?\n");
187			exit(1);
188			}
189
190			tmpexp = atoll(cp);
191			/* Do some sanity checking - if value is bogus, just exit because
192			* the table otherwise is probably in an inconsistent state
193			*/
194			if (tmpexp <= lastexp) {
195	elmex	1.1	#ifndef WIN32
196	root	1.2	LOG(llevError,"Experience for level %d is lower than previous level (%lld <= %lld)\n",
197			lastlevel + 1, tmpexp, lastexp);
198	elmex	1.1	#else
199	root	1.2	LOG(llevError,"Experience for level %d is lower than previous level (%I64d <= %I64d)\n",
200			lastlevel + 1, tmpexp, lastexp);
201	elmex	1.1	#endif
202	root	1.2	exit(1);
203			}
204			lastlevel++;
205			if (lastlevel > settings.max_level) {
206			LOG(llevError,"Too many levels specified in table (%d > %d)\n",
207			lastlevel, settings.max_level);
208			exit(1);
209			}
210			levels[lastlevel] = tmpexp;
211			lastexp = tmpexp;
212			/* First, skip over the number we just processed. Then skip over
213			* any spaces, commas, etc.
214			*/
215			while (isdigit(cp) && cp!=0) cp++;
216			while (!isdigit(cp) && cp!=0) cp++;
217			}
218	elmex	1.1	}
219			close_and_delete(fp, comp);
220			if (lastlevel != settings.max_level && lastlevel != 0) {
221	root	1.2	LOG(llevError,"Warning: exp_table does not have %d entries (%d)\n",
222			settings.max_level, lastlevel);
223			exit(1);
224	elmex	1.1	}
225			}
226
227			/* Dump the table - useful in terms of debugging to make sure the
228			* format of the exp_table is correct.
229			*/
230
231			void dump_experience()
232			{
233			int i;
234
235			for (i=1; i<= settings.max_level; i++) {
236	root	1.4	fprintf(logfile,"%4d %20lld\n", i, (long long)levels[i]);
237	elmex	1.1	}
238			exit(0);
239			}