server/common/exp.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <crossfire@schmorp.de>
 */

#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)
            {
              LOG (llevError, "Experience for level %d is lower than previous level (%" PRId64 " <= %" PRId64 ")\n", lastlevel + 1, tmpexp, lastexp);
              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.16
Committed:	Sun Jul 1 05:00:17 2007 UTC (16 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_2, rel-2_3
Changes since 1.15:	+11 -12 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.
#	Content
1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/
23
24	#include <stdio.h>
25	#include <global.h>
26
27	sint64 *levels;
28
29	float exp_att_mult[NROFATTACKS + 2] = {
30	0.0, /* AT_PHYSICAL */
31	0.0, /* AT_MAGIC */
32	0.0, /* AT_FIRE */
33	0.0, /* AT_ELECTRICITY */
34	0.0, /* AT_COLD */
35	0.0, /* AT_WATER //AT_CONFUSION! */
36	0.4, /* AT_ACID */
37	1.5, /* AT_DRAIN */
38	0.0, /* AT_WEAPONMAGIC */
39	0.1, /* AT_GHOSTHIT */
40	0.3, /* AT_POISON */
41	0.2, /* AT_DISEASE */
42	0.3, /* AT_PARALYZE */
43	0.0, /* AT_TURN_UNDEAD */
44	0.0, /* AT_FEAR */
45	0.0, /* AT_CANCELLATION */
46	0.0, /* AT_DEPLETE */
47	0.0, /* AT_DEATH */
48	0.0, /* AT_CHAOS */
49	0.0 /* AT_COUNTERSPELL */
50	};
51
52	float exp_prot_mult[NROFATTACKS + 2] = {
53	0.4, /* AT_PHYSICAL */
54	0.5, /* AT_MAGIC */
55	0.1, /* AT_FIRE */
56	0.1, /* AT_ELECTRICITY */
57	0.1, /* AT_COLD */
58	0.1, /* AT_WATER */
59	0.1, /* AT_ACID */
60	0.1, /* AT_DRAIN */
61	0.1, /* AT_WEAPONMAGIC */
62	0.1, /* AT_GHOSTHIT */
63	0.1, /* AT_POISON */
64	0.1, /* AT_DISEASE */
65	0.1, /* AT_PARALYZE */
66	0.1, /* AT_TURN_UNDEAD */
67	0.1, /* AT_FEAR */
68	0.0, /* AT_CANCELLATION */
69	0.0, /* AT_DEPLETE */
70	0.0, /* AT_DEATH */
71	0.0, /* AT_CHAOS */
72	0.0 /* AT_COUNTERSPELL */
73	};
74
75	/*
76	* new_exp() is an alternative way to calculate experience based
77	* on the ability of a monster.
78	* It's far from perfect, and doesn't consider everything which
79	* can be considered, thus it's only used in debugging.
80	* this is only used with one of the dumpflags,
81	* and not anyplace in the code.
82	*/
83	int
84	new_exp (const object *ob)
85	{
86	double att_mult, prot_mult, spec_mult;
87	double exp;
88	int i;
89	long mask = 1;
90
91	att_mult = prot_mult = spec_mult = 1.0;
92	for (i = 0; i < NROFATTACKS; i++)
93	{
94	mask = 1 << i;
95	att_mult += (exp_att_mult[i] * ((ob->attacktype & mask) != 0));
96	/* We multiply & then divide to prevent roundoffs on the floats.
97	* the doubling is to take into account the table and resistances
98	* are lower than they once were.
99	*/
100	prot_mult += (exp_prot_mult[i] * 200 * ob->resist[i]) / 100.0;
101	}
102	spec_mult += (0.3 * (QUERY_FLAG (ob, FLAG_SEE_INVISIBLE) != 0)) +
103	(0.5 * (QUERY_FLAG (ob, FLAG_SPLITTING) != 0)) +
104	(0.3 * (QUERY_FLAG (ob, FLAG_HITBACK) != 0)) +
105	(0.1 * (QUERY_FLAG (ob, FLAG_REFL_MISSILE) != 0)) +
106	(0.3 * (QUERY_FLAG (ob, FLAG_REFL_SPELL) != 0)) +
107	(1.0 * (QUERY_FLAG (ob, FLAG_NO_MAGIC) != 0)) +
108	(0.1 * (QUERY_FLAG (ob, FLAG_PICK_UP) != 0)) +
109	(0.1 * (QUERY_FLAG (ob, FLAG_USE_SCROLL) != 0)) +
110	(0.2 * (QUERY_FLAG (ob, FLAG_USE_RANGE) != 0)) + (0.1 * (QUERY_FLAG (ob, FLAG_USE_BOW) != 0));
111
112	exp = (ob->stats.maxhp < 5) ? 5 : ob->stats.maxhp;
113	exp *= (QUERY_FLAG (ob, FLAG_CAST_SPELL) && has_ability (ob)) ? (40 + (ob->stats.maxsp > 80 ? 80 : ob->stats.maxsp)) / 40 : 1;
114	exp = (80.0 / (70.0 + ob->stats.wc)) (80.0 / (70.0 + ob->stats.ac)) * (50.0 + ob->stats.dam) / 50.0;
115	exp = att_mult prot_mult * spec_mult;
116	exp *= 2.0 / (2.0 - ((fabs (ob->speed) < 0.95) ? fabs (ob->speed) : 0.95));
117	exp *= (20.0 + ob->stats.Con) / 20.0;
118	if (QUERY_FLAG (ob, FLAG_STAND_STILL))
119	exp /= 2;
120
121	return (int) exp;
122	}
123
124	/*
125	* Returns true if the monster specified has any innate abilities.
126	*/
127
128	int
129	has_ability (const object *ob)
130	{
131	object *tmp;
132
133	for (tmp = ob->inv; tmp != NULL; tmp = tmp->below)
134	if (tmp->type == SPELL \|\| tmp->type == SPELLBOOK)
135	return true;
136	return false;
137	}
138
139	/* This loads the experience table from the exp_table
140	* file. This tends to exit on any errors, since it
141	* populates the table as it goes along, so if there
142	* are errors, the table is likely in an inconsistent
143	* state.
144	*/
145	void
146	init_experience (void)
147	{
148	char buf[MAX_BUF], *cp;
149	int lastlevel = 0, comp;
150	sint64 lastexp = -1, tmpexp;
151	FILE *fp;
152
153
154	sprintf (buf, "%s/exp_table", settings.confdir);
155
156	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
157	{
158	return;
159	}
160	while (fgets (buf, MAX_BUF - 1, fp) != NULL)
161	{
162	if (buf[0] == '#')
163	continue;
164
165	/* eliminate newline */
166	if ((cp = strrchr (buf, '\n')) != NULL)
167	*cp = '\0';
168
169	/* Skip over empty lines */
170	if (buf[0] == 0)
171	continue;
172	cp = buf;
173	while (isspace (cp) && cp != 0)
174	cp++;
175	if (!strncasecmp (cp, "max_level", 9))
176	{
177	if (settings.max_level)
178	{
179	LOG (llevDebug, "Got more than one max_level value from exp_table file?\n");
180	free (levels);
181	}
182	settings.max_level = atoi (cp + 9);
183	if (!settings.max_level)
184	{
185	LOG (llevDebug, "Got invalid max_level from exp_table file? %s\n", buf);
186	}
187	else
188	{
189	levels = (sint64 *) calloc (settings.max_level + 1, sizeof (sint64));
190	}
191	}
192	while (isdigit (cp) && cp != 0)
193	{
194	if (!settings.max_level)
195	{
196	LOG (llevError, "max_level is not set in exp_table file. Did you remember to update it?\n");
197	exit (1);
198	}
199
200	tmpexp = atoll (cp);
201	/* Do some sanity checking - if value is bogus, just exit because
202	* the table otherwise is probably in an inconsistent state
203	*/
204	if (tmpexp <= lastexp)
205	{
206	LOG (llevError, "Experience for level %d is lower than previous level (%" PRId64 " <= %" PRId64 ")\n", lastlevel + 1, tmpexp, lastexp);
207	exit (1);
208	}
209	lastlevel++;
210	if (lastlevel > settings.max_level)
211	{
212	LOG (llevError, "Too many levels specified in table (%d > %d)\n", lastlevel, settings.max_level);
213	exit (1);
214	}
215	levels[lastlevel] = tmpexp;
216	lastexp = tmpexp;
217	/* First, skip over the number we just processed. Then skip over
218	* any spaces, commas, etc.
219	*/
220	while (isdigit (cp) && cp != 0)
221	cp++;
222	while (!isdigit (cp) && cp != 0)
223	cp++;
224	}
225	}
226	close_and_delete (fp, comp);
227	if (lastlevel != settings.max_level && lastlevel != 0)
228	{
229	LOG (llevError, "Warning: exp_table does not have %d entries (%d)\n", settings.max_level, lastlevel);
230	exit (1);
231	}
232	}
233
234	/* Dump the table - useful in terms of debugging to make sure the
235	* format of the exp_table is correct.
236	*/
237
238	void
239	dump_experience ()
240	{
241	int i;
242
243	for (i = 1; i <= settings.max_level; i++)
244	{
245	fprintf (logfile, "%4d %20lld\n", i, (long long) levels[i]);
246	}
247	exit (0);
248	}