server/common/utils.C

/*
    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@schmorp.de>
*/

/*
 * General convenience functions for crossfire.
 */

#include <global.h>
#include <funcpoint.h>
#include <material.h>

#include <glib.h>

/*
 * The random functions here take luck into account when rolling random
 * dice or numbers.  This function has less of an impact the larger the
 * difference becomes in the random numbers.  IE, the effect is lessened
 * on a 1-1000 roll, vs a 1-6 roll.  This can be used by crafty programmers,
 * to specifically disable luck in certain rolls, simply by making the
 * numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)
 */

/*
 * Roll a random number between min and max.  Uses op to determine luck,
 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
 * Generally, op should be the player/caster/hitter requesting the roll,
 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
 */

int
random_roll (int min, int max, const object *op, int goodbad)
{
  int omin, diff, luck, base, ran;

  omin = min;
  diff = max - min + 1;
  ((diff > 2) ? (base = 20) : (base = 50));     /* d2 and d3 are corner cases */

  if (max < 1 || diff < 1)
    {
      LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);
      return (min);             /* avoids a float exception */
    }

  ran = RANDOM ();

  if (op->type != PLAYER)
    return ((ran % diff) + min);

  luck = op->stats.luck;
  if (RANDOM () % base < MIN (10, abs (luck)))
    {
      /* we have a winner */
      ((luck > 0) ? (luck = 1) : (luck = -1));
      diff -= luck;
      if (diff < 1)
        return (omin);          /*check again */
      ((goodbad) ? (min += luck) : (diff));

      return (MAX (omin, MIN (max, (ran % diff) + min)));
    }
  return ((ran % diff) + min);
}

/*
 * This is a 64 bit version of random_roll above.  This is needed
 * for exp loss calculations for players changing religions.
 */

sint64
random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
{
  sint64 omin, diff, luck, ran;
  int base;

  omin = min;
  diff = max - min + 1;
  ((diff > 2) ? (base = 20) : (base = 50));     /* d2 and d3 are corner cases */

  if (max < 1 || diff < 1)
    {
      LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
      return (min);             /* avoids a float exception */
    }

  /* Don't know of a portable call to get 64 bit random values.
   * So make a call to get two 32 bit random numbers, and just to
   * a little byteshifting.  Do make sure the first one is only
   * 32 bit, so we don't get skewed results
   */
  ran = (RANDOM () & 0xffffffff) | ((sint64) RANDOM () << 32);

  if (op->type != PLAYER)
    return ((ran % diff) + min);

  luck = op->stats.luck;
  if (RANDOM () % base < MIN (10, abs (luck)))
    {
      /* we have a winner */
      ((luck > 0) ? (luck = 1) : (luck = -1));
      diff -= luck;
      if (diff < 1)
        return (omin);          /*check again */
      ((goodbad) ? (min += luck) : (diff));

      return (MAX (omin, MIN (max, (ran % diff) + min)));
    }
  return ((ran % diff) + min);
}

/*
 * Roll a number of dice (2d3, 4d6).  Uses op to determine luck,
 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
 * Generally, op should be the player/caster/hitter requesting the roll,
 * not the recipient (ie, the poor slob getting hit).
 * The args are num D size (ie 4d6)  [garbled 20010916]
 */

int
die_roll (int num, int size, const object *op, int goodbad)
{
  int min, diff, luck, total, i, gotlucky, base, ran;

  diff = size;
  min = 1;
  luck = total = gotlucky = 0;
  ((diff > 2) ? (base = 20) : (base = 50));     /* d2 and d3 are corner cases */
  if (size < 2 || diff < 1)
    {
      LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
      return (num);             /* avoids a float exception */
    }

  if (op->type == PLAYER)
    luck = op->stats.luck;

  for (i = 0; i < num; i++)
    {
      if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky)
        {
          /* we have a winner */
          gotlucky++;
          ((luck > 0) ? (luck = 1) : (luck = -1));
          diff -= luck;
          if (diff < 1)
            return (num);       /*check again */
          ((goodbad) ? (min += luck) : (diff));
          ran = RANDOM ();
          total += MAX (1, MIN (size, (ran % diff) + min));
        }
      else
        {
          total += RANDOM () % size + 1;
        }
    }
  return (total);
}

/*
 * Another convenience function.  Returns a number between min and max.
 * It is suggested one use these functions rather than RANDOM()%, as it
 * would appear that a number of off-by-one-errors exist due to improper
 * use of %.  This should also prevent SIGFPE.
 */

int
rndm (int min, int max)
{
  int diff;

  diff = max - min + 1;
  if (max < 1 || diff < 1)
    return (min);

  return (RANDOM () % diff + min);
}

/* decay and destroy persihable items in a map */

void
decay_objects (maptile *m)
{
  int x, y, destroy;
  object *op, *otmp;

  if (m->unique)
    return;

  for (x = 0; x < MAP_WIDTH (m); x++)
    for (y = 0; y < MAP_HEIGHT (m); y++)
      for (op = get_map_ob (m, x, y); op; op = otmp)
        {
          destroy = 0;
          otmp = op->above;
          if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
            break;
          if (QUERY_FLAG (op, FLAG_IS_FLOOR) ||
              QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) ||
              QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) ||
              QUERY_FLAG (op, FLAG_UNIQUE) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) || QUERY_FLAG (op, FLAG_UNPAID) || IS_LIVE (op))
            continue;
          /* otherwise, we decay and destroy */
          if (IS_WEAPON (op))
            {
              op->stats.dam--;
              if (op->stats.dam < 0)
                destroy = 1;
            }
          else if (IS_ARMOR (op))
            {
              op->stats.ac--;
              if (op->stats.ac < 0)
                destroy = 1;
            }
          else if (op->type == FOOD)
            {
              op->stats.food -= rndm (5, 20);
              if (op->stats.food < 0)
                destroy = 1;
            }
          else
            {
              if (op->material & M_PAPER || op->material & M_LEATHER ||
                  op->material & M_WOOD || op->material & M_ORGANIC || op->material & M_CLOTH || op->material & M_LIQUID)
                destroy = 1;
              if (op->material & M_IRON && rndm (1, 5) == 1)
                destroy = 1;
              if (op->material & M_GLASS && rndm (1, 2) == 1)
                destroy = 1;
              if ((op->material & M_STONE || op->material & M_ADAMANT) && rndm (1, 10) == 1)
                destroy = 1;
              if ((op->material & M_SOFT_METAL || op->material & M_BONE) && rndm (1, 3) == 1)
                destroy = 1;
              if (op->material & M_ICE && MAP_TEMP (m) > 32)
                destroy = 1;
            }
          /* adjust overall chance below */
          if (destroy && rndm (0, 1))
            op->destroy ();
        }
}

/* convert materialname to materialtype_t */

materialtype_t *
name_to_material (const char *name)
{
  materialtype_t *mt, *nmt;

  mt = NULL;
  for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
    {
      if (strcmp (name, nmt->name) == 0)
        {
          mt = nmt;
          break;
        }
    }
  return mt;
}

/* when doing transmutation of objects, we have to recheck the resistances,
 * as some that did not apply previously, may apply now.
 */

void
transmute_materialname (object *op, const object *change)
{
  materialtype_t *mt;
  int j;

  if (op->materialname == NULL)
    return;

  if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
    return;

  if (!IS_ARMOR (op))
    return;

  mt = name_to_material (op->materialname);
  if (!mt)
    {
      LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);
      return;
    }

  for (j = 0; j < NROFATTACKS; j++)
    if (op->resist[j] == 0 && change->resist[j] != 0)
      {
        op->resist[j] += mt->mod[j];
        if (op->resist[j] > 100)
          op->resist[j] = 100;
        if (op->resist[j] < -100)
          op->resist[j] = -100;
      }
}

/* set the materialname and type for an item */
void
set_materialname (object *op, int difficulty, materialtype_t *nmt)
{
  materialtype_t *mt, *lmt;

#ifdef NEW_MATERIAL_CODE
  int j;
#endif

  if (op->materialname != NULL)
    return;


  if (nmt == NULL)
    {
      lmt = NULL;
#ifndef NEW_MATERIAL_CODE
      for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
        {
          if (op->material & mt->material)
            {
              lmt = mt;
              break;
            }
        }

#else
      for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
        {
          if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
              difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
            {
              lmt = mt;
              if (!(IS_WEAPON (op) || IS_ARMOR (op)))
                break;
            }
        }
#endif
    }
  else
    {
      lmt = nmt;
    }

  if (lmt != NULL)
    {
#ifndef NEW_MATERIAL_CODE
      op->materialname = lmt->name;
      return;
#else

      if (op->stats.dam && IS_WEAPON (op))
        {
          op->stats.dam += lmt->damage;
          if (op->stats.dam < 1)
            op->stats.dam = 1;
        }
      if (op->stats.sp && op->type == BOW)
        op->stats.sp += lmt->sp;
      if (op->stats.wc && IS_WEAPON (op))
        op->stats.wc += lmt->wc;
      if (IS_ARMOR (op))
        {
          if (op->stats.ac)
            op->stats.ac += lmt->ac;
          for (j = 0; j < NROFATTACKS; j++)
            if (op->resist[j] != 0)
              {
                op->resist[j] += lmt->mod[j];
                if (op->resist[j] > 100)
                  op->resist[j] = 100;
                if (op->resist[j] < -100)
                  op->resist[j] = -100;
              }
        }
      op->materialname = add_string (lmt->name);
      /* dont make it unstackable if it doesn't need to be */
      if (IS_WEAPON (op) || IS_ARMOR (op))
        {
          op->weight = (op->weight * lmt->weight) / 100;
          op->value = (op->value * lmt->value) / 100;
        }
#endif
    }
}

/*
 * Strip out the media tags from a String.
 * Warning the input string will contain the result string
 */
void
strip_media_tag (char *message)
{
  int in_tag = 0;
  char *dest;
  char *src;

  src = dest = message;
  while (*src != '\0')
    {
      if (*src == '[')
        {
          in_tag = 1;
        }
      else if (in_tag && (*src == ']'))
        in_tag = 0;
      else if (!in_tag)
        {
          *dest = *src;
          dest++;
        }
      src++;
    }
  *dest = '\0';
}

const char *
strrstr (const char *haystack, const char *needle)
{
  const char *lastneedle;

  lastneedle = NULL;
  while ((haystack = strstr (haystack, needle)) != NULL)
    {
      lastneedle = haystack;
      haystack++;
    }
  return lastneedle;

}

#define EOL_SIZE (sizeof("\n")-1)
void
strip_endline (char *buf)
{
  if (strlen (buf) < sizeof ("\n"))
    {
      return;
    }
  if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
    buf[strlen (buf) - EOL_SIZE] = '\0';
}

/**
 * Replace in string src all occurrences of key by replacement. The resulting
 * string is put into result; at most resultsize characters (including the
 * terminating null character) will be written to result.
 */
void
replace (const char *src, const char *key, const char *replacement, char *result, size_t resultsize)
{
  size_t resultlen;
  size_t keylen;

  /* special case to prevent infinite loop if key==replacement=="" */
  if (strcmp (key, replacement) == 0)
    {
      snprintf (result, resultsize, "%s", src);
      return;
    }

  keylen = strlen (key);

  resultlen = 0;
  while (*src != '\0' && resultlen + 1 < resultsize)
    {
      if (strncmp (src, key, keylen) == 0)
        {
          snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
          resultlen += strlen (result + resultlen);
          src += keylen;
        }
      else
        {
          result[resultlen++] = *src++;
        }
    }
  result[resultlen] = '\0';
}

/**
 * Taking a string as an argument, mutate it into a string that looks like a list.
 * a 'list' for the purposes here, is a string of items, seperated by commas, except
 * for the last entry, which has an 'and' before it, and a full stop (period) after it.
 * This function will also strip all trailing non alphanumeric characters.
 * It does not insert an oxford comma.
 */

void
make_list_like (char *input)
{
  char *p, tmp[MAX_BUF];
  int i;

  if (!input || strlen (input) > MAX_BUF - 5)
    return;
  /* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */

  strncpy (tmp, input, MAX_BUF - 5);
  /*trim all trailing commas, spaces etc. */
  for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
    tmp[i] = '\0';

  strcat (tmp, ".");

  p = strrchr (tmp, ',');
  if (p)
    {
      *p = '\0';
      strcpy (input, tmp);
      p++;
      strcat (input, " and");
      strcat (input, p);
    }
  else
    strcpy (input, tmp);

  return;
}

/////////////////////////////////////////////////////////////////////////////

#if 0
refcounted *refcounted::rc_first;

refcounted::refcounted ()
{
  refcnt   = 0;
  rc_next  = rc_first;
  rc_first = this;
}

refcounted::~refcounted ()
{
  assert (!rc_next);
  assert (!refcnt);
}
#endif

void *alloc (int s) throw (std::bad_alloc)
{
  void *p = g_slice_alloc (s);

  if (!p)
    throw std::bad_alloc ();

  return p;
}

void assign (char *dst, const char *src, int maxlen)
{
  if (!src)
    src = "";

  int len = strlen (src);

  if (len >= maxlen - 1)
    {
      if (maxlen <= 4)
        {
          memset (dst, '.', maxlen - 1);
          dst [maxlen - 1] = 0;
        }
      else
        {
          memcpy (dst, src, maxlen - 4);
          memcpy (dst + maxlen - 4, "...", 4);
        }
    }
  else
    memcpy (dst, src, len + 1);
}


Revision:	1.22
Committed:	Tue Dec 12 21:39:56 2006 UTC (17 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.21:	+1 -4 lines
Log Message:	- more ooficiation - removed now superfluous remove calls
#	User	Rev	Content
1	elmex	1.1	/*
2			CrossFire, A Multiplayer game for X-windows
3
4			Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5			Copyright (C) 1992 Frank Tore Johansen
6
7			This program is free software; you can redistribute it and/or modify
8			it under the terms of the GNU General Public License as published by
9			the Free Software Foundation; either version 2 of the License, or
10			(at your option) any later version.
11
12			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License
18			along with this program; if not, write to the Free Software
19			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
21	root	1.15	The authors can be reached via e-mail at <crossfire@schmorp.de>
22	elmex	1.1	*/
23
24			/*
25			* General convenience functions for crossfire.
26			*/
27
28			#include <global.h>
29			#include <funcpoint.h>
30			#include <material.h>
31
32	root	1.4	#include <glib.h>
33
34	elmex	1.1	/*
35			* The random functions here take luck into account when rolling random
36			* dice or numbers. This function has less of an impact the larger the
37			* difference becomes in the random numbers. IE, the effect is lessened
38			* on a 1-1000 roll, vs a 1-6 roll. This can be used by crafty programmers,
39			* to specifically disable luck in certain rolls, simply by making the
40			* numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)
41			*/
42
43			/*
44			* Roll a random number between min and max. Uses op to determine luck,
45			* and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
46			* Generally, op should be the player/caster/hitter requesting the roll,
47			* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
48			*/
49
50	root	1.9	int
51			random_roll (int min, int max, const object *op, int goodbad)
52			{
53			int omin, diff, luck, base, ran;
54	elmex	1.1
55	root	1.9	omin = min;
56			diff = max - min + 1;
57			((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
58	elmex	1.1
59	root	1.9	if (max < 1 \|\| diff < 1)
60			{
61			LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);
62			return (min); /* avoids a float exception */
63	elmex	1.1	}
64
65	root	1.9	ran = RANDOM ();
66	elmex	1.1
67	root	1.9	if (op->type != PLAYER)
68			return ((ran % diff) + min);
69	elmex	1.1
70	root	1.9	luck = op->stats.luck;
71			if (RANDOM () % base < MIN (10, abs (luck)))
72			{
73			/* we have a winner */
74			((luck > 0) ? (luck = 1) : (luck = -1));
75			diff -= luck;
76			if (diff < 1)
77			return (omin); /check again /
78			((goodbad) ? (min += luck) : (diff));
79	elmex	1.1
80	root	1.9	return (MAX (omin, MIN (max, (ran % diff) + min)));
81	elmex	1.1	}
82	root	1.9	return ((ran % diff) + min);
83	elmex	1.1	}
84
85			/*
86			* This is a 64 bit version of random_roll above. This is needed
87			* for exp loss calculations for players changing religions.
88			*/
89
90	root	1.9	sint64
91			random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
92			{
93			sint64 omin, diff, luck, ran;
94			int base;
95
96			omin = min;
97			diff = max - min + 1;
98			((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
99	elmex	1.1
100	root	1.9	if (max < 1 \|\| diff < 1)
101			{
102	root	1.20	LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
103	root	1.9	return (min); /* avoids a float exception */
104	elmex	1.1	}
105
106	root	1.9	/* Don't know of a portable call to get 64 bit random values.
107			* So make a call to get two 32 bit random numbers, and just to
108			* a little byteshifting. Do make sure the first one is only
109			* 32 bit, so we don't get skewed results
110			*/
111			ran = (RANDOM () & 0xffffffff) \| ((sint64) RANDOM () << 32);
112
113			if (op->type != PLAYER)
114			return ((ran % diff) + min);
115
116			luck = op->stats.luck;
117			if (RANDOM () % base < MIN (10, abs (luck)))
118			{
119			/* we have a winner */
120			((luck > 0) ? (luck = 1) : (luck = -1));
121			diff -= luck;
122			if (diff < 1)
123			return (omin); /check again /
124			((goodbad) ? (min += luck) : (diff));
125	elmex	1.1
126	root	1.9	return (MAX (omin, MIN (max, (ran % diff) + min)));
127	elmex	1.1	}
128	root	1.9	return ((ran % diff) + min);
129	elmex	1.1	}
130
131			/*
132			* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
133			* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
134			* Generally, op should be the player/caster/hitter requesting the roll,
135			* not the recipient (ie, the poor slob getting hit).
136			* The args are num D size (ie 4d6) [garbled 20010916]
137			*/
138
139	root	1.9	int
140			die_roll (int num, int size, const object *op, int goodbad)
141			{
142			int min, diff, luck, total, i, gotlucky, base, ran;
143
144			diff = size;
145			min = 1;
146			luck = total = gotlucky = 0;
147			((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
148			if (size < 2 \|\| diff < 1)
149			{
150			LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
151			return (num); /* avoids a float exception */
152			}
153	elmex	1.1
154	root	1.9	if (op->type == PLAYER)
155			luck = op->stats.luck;
156
157			for (i = 0; i < num; i++)
158			{
159			if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky)
160			{
161			/* we have a winner */
162			gotlucky++;
163			((luck > 0) ? (luck = 1) : (luck = -1));
164			diff -= luck;
165			if (diff < 1)
166			return (num); /check again /
167			((goodbad) ? (min += luck) : (diff));
168			ran = RANDOM ();
169			total += MAX (1, MIN (size, (ran % diff) + min));
170			}
171			else
172			{
173			total += RANDOM () % size + 1;
174	root	1.2	}
175	elmex	1.1	}
176	root	1.9	return (total);
177	elmex	1.1	}
178
179			/*
180			* Another convenience function. Returns a number between min and max.
181			* It is suggested one use these functions rather than RANDOM()%, as it
182			* would appear that a number of off-by-one-errors exist due to improper
183			* use of %. This should also prevent SIGFPE.
184			*/
185
186	root	1.9	int
187			rndm (int min, int max)
188	elmex	1.1	{
189			int diff;
190
191			diff = max - min + 1;
192			if (max < 1 \|\| diff < 1)
193	root	1.9	return (min);
194	elmex	1.1
195	root	1.9	return (RANDOM () % diff + min);
196	elmex	1.1	}
197
198			/* decay and destroy persihable items in a map */
199
200	root	1.9	void
201	root	1.16	decay_objects (maptile *m)
202	elmex	1.1	{
203	root	1.9	int x, y, destroy;
204			object op, otmp;
205	elmex	1.1
206	root	1.9	if (m->unique)
207			return;
208	elmex	1.1
209	root	1.9	for (x = 0; x < MAP_WIDTH (m); x++)
210			for (y = 0; y < MAP_HEIGHT (m); y++)
211			for (op = get_map_ob (m, x, y); op; op = otmp)
212			{
213			destroy = 0;
214			otmp = op->above;
215			if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
216			break;
217			if (QUERY_FLAG (op, FLAG_IS_FLOOR) \|\|
218			QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) \|\|
219			QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) \|\|
220			QUERY_FLAG (op, FLAG_UNIQUE) \|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) \|\| QUERY_FLAG (op, FLAG_UNPAID) \|\| IS_LIVE (op))
221			continue;
222			/* otherwise, we decay and destroy */
223			if (IS_WEAPON (op))
224			{
225			op->stats.dam--;
226			if (op->stats.dam < 0)
227			destroy = 1;
228	root	1.2	}
229	root	1.9	else if (IS_ARMOR (op))
230			{
231			op->stats.ac--;
232			if (op->stats.ac < 0)
233			destroy = 1;
234			}
235			else if (op->type == FOOD)
236			{
237			op->stats.food -= rndm (5, 20);
238			if (op->stats.food < 0)
239			destroy = 1;
240			}
241			else
242			{
243			if (op->material & M_PAPER \|\| op->material & M_LEATHER \|\|
244			op->material & M_WOOD \|\| op->material & M_ORGANIC \|\| op->material & M_CLOTH \|\| op->material & M_LIQUID)
245			destroy = 1;
246			if (op->material & M_IRON && rndm (1, 5) == 1)
247			destroy = 1;
248			if (op->material & M_GLASS && rndm (1, 2) == 1)
249			destroy = 1;
250			if ((op->material & M_STONE \|\| op->material & M_ADAMANT) && rndm (1, 10) == 1)
251			destroy = 1;
252			if ((op->material & M_SOFT_METAL \|\| op->material & M_BONE) && rndm (1, 3) == 1)
253			destroy = 1;
254			if (op->material & M_ICE && MAP_TEMP (m) > 32)
255			destroy = 1;
256			}
257			/* adjust overall chance below */
258			if (destroy && rndm (0, 1))
259	root	1.22	op->destroy ();
260	root	1.9	}
261	elmex	1.1	}
262
263			/* convert materialname to materialtype_t */
264
265	root	1.9	materialtype_t *
266			name_to_material (const char *name)
267	elmex	1.1	{
268	root	1.9	materialtype_t mt, nmt;
269	elmex	1.1
270	root	1.9	mt = NULL;
271			for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
272			{
273			if (strcmp (name, nmt->name) == 0)
274			{
275			mt = nmt;
276			break;
277	root	1.2	}
278	elmex	1.1	}
279	root	1.9	return mt;
280	elmex	1.1	}
281
282			/* when doing transmutation of objects, we have to recheck the resistances,
283			* as some that did not apply previously, may apply now.
284			*/
285
286	root	1.9	void
287			transmute_materialname (object op, const object change)
288	elmex	1.1	{
289	root	1.9	materialtype_t *mt;
290			int j;
291	elmex	1.1
292	root	1.9	if (op->materialname == NULL)
293			return;
294	elmex	1.1
295	root	1.9	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
296			return;
297
298			if (!IS_ARMOR (op))
299			return;
300
301			mt = name_to_material (op->materialname);
302			if (!mt)
303			{
304			LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);
305			return;
306			}
307
308			for (j = 0; j < NROFATTACKS; j++)
309			if (op->resist[j] == 0 && change->resist[j] != 0)
310			{
311			op->resist[j] += mt->mod[j];
312			if (op->resist[j] > 100)
313			op->resist[j] = 100;
314			if (op->resist[j] < -100)
315			op->resist[j] = -100;
316			}
317	elmex	1.1	}
318
319			/* set the materialname and type for an item */
320	root	1.9	void
321			set_materialname (object op, int difficulty, materialtype_t nmt)
322	elmex	1.1	{
323	root	1.9	materialtype_t mt, lmt;
324
325	pippijn	1.5	#ifdef NEW_MATERIAL_CODE
326	root	1.9	int j;
327	pippijn	1.5	#endif
328	elmex	1.1
329	root	1.9	if (op->materialname != NULL)
330			return;
331	elmex	1.1
332
333
334	root	1.9	if (nmt == NULL)
335			{
336			lmt = NULL;
337	elmex	1.1	#ifndef NEW_MATERIAL_CODE
338	root	1.9	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
339			{
340			if (op->material & mt->material)
341			{
342			lmt = mt;
343			break;
344	root	1.2	}
345			}
346	elmex	1.1
347			#else
348	root	1.9	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
349			{
350			if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
351			difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
352			{
353			lmt = mt;
354			if (!(IS_WEAPON (op) \|\| IS_ARMOR (op)))
355			break;
356	root	1.2	}
357			}
358	elmex	1.1	#endif
359	root	1.9	}
360			else
361			{
362			lmt = nmt;
363	elmex	1.1	}
364
365	root	1.9	if (lmt != NULL)
366			{
367	elmex	1.1	#ifndef NEW_MATERIAL_CODE
368	root	1.9	op->materialname = lmt->name;
369			return;
370	elmex	1.1	#else
371
372	root	1.9	if (op->stats.dam && IS_WEAPON (op))
373			{
374			op->stats.dam += lmt->damage;
375			if (op->stats.dam < 1)
376			op->stats.dam = 1;
377			}
378			if (op->stats.sp && op->type == BOW)
379			op->stats.sp += lmt->sp;
380			if (op->stats.wc && IS_WEAPON (op))
381			op->stats.wc += lmt->wc;
382			if (IS_ARMOR (op))
383			{
384			if (op->stats.ac)
385			op->stats.ac += lmt->ac;
386			for (j = 0; j < NROFATTACKS; j++)
387			if (op->resist[j] != 0)
388			{
389			op->resist[j] += lmt->mod[j];
390			if (op->resist[j] > 100)
391			op->resist[j] = 100;
392			if (op->resist[j] < -100)
393			op->resist[j] = -100;
394			}
395			}
396			op->materialname = add_string (lmt->name);
397			/* dont make it unstackable if it doesn't need to be */
398			if (IS_WEAPON (op) \|\| IS_ARMOR (op))
399			{
400			op->weight = (op->weight * lmt->weight) / 100;
401			op->value = (op->value * lmt->value) / 100;
402	root	1.2	}
403	elmex	1.1	#endif
404			}
405			}
406
407			/*
408			* Strip out the media tags from a String.
409			* Warning the input string will contain the result string
410			*/
411	root	1.9	void
412			strip_media_tag (char *message)
413			{
414			int in_tag = 0;
415			char *dest;
416			char *src;
417
418			src = dest = message;
419			while (*src != '\0')
420			{
421			if (*src == '[')
422			{
423			in_tag = 1;
424			}
425			else if (in_tag && (*src == ']'))
426			in_tag = 0;
427			else if (!in_tag)
428			{
429			dest = src;
430			dest++;
431			}
432			src++;
433			}
434			*dest = '\0';
435			}
436
437			const char *
438			strrstr (const char haystack, const char needle)
439			{
440			const char *lastneedle;
441
442			lastneedle = NULL;
443			while ((haystack = strstr (haystack, needle)) != NULL)
444			{
445			lastneedle = haystack;
446			haystack++;
447	elmex	1.1	}
448	root	1.9	return lastneedle;
449
450	elmex	1.1	}
451	root	1.9
452	elmex	1.1	#define EOL_SIZE (sizeof("\n")-1)
453	root	1.9	void
454			strip_endline (char *buf)
455			{
456			if (strlen (buf) < sizeof ("\n"))
457			{
458			return;
459	elmex	1.1	}
460	root	1.9	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
461			buf[strlen (buf) - EOL_SIZE] = '\0';
462	elmex	1.1	}
463
464			/**
465			* Replace in string src all occurrences of key by replacement. The resulting
466			* string is put into result; at most resultsize characters (including the
467			* terminating null character) will be written to result.
468			*/
469	root	1.9	void
470			replace (const char src, const char key, const char replacement, char result, size_t resultsize)
471	elmex	1.1	{
472	root	1.9	size_t resultlen;
473			size_t keylen;
474	elmex	1.1
475	root	1.9	/* special case to prevent infinite loop if key==replacement=="" */
476			if (strcmp (key, replacement) == 0)
477			{
478			snprintf (result, resultsize, "%s", src);
479			return;
480			}
481
482			keylen = strlen (key);
483
484			resultlen = 0;
485			while (*src != '\0' && resultlen + 1 < resultsize)
486			{
487			if (strncmp (src, key, keylen) == 0)
488	root	1.2	{
489	root	1.9	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
490			resultlen += strlen (result + resultlen);
491			src += keylen;
492	root	1.2	}
493	root	1.9	else
494	root	1.2	{
495	root	1.9	result[resultlen++] = *src++;
496	root	1.2	}
497	root	1.9	}
498			result[resultlen] = '\0';
499	elmex	1.1	}
500
501			/**
502			* Taking a string as an argument, mutate it into a string that looks like a list.
503			* a 'list' for the purposes here, is a string of items, seperated by commas, except
504			* for the last entry, which has an 'and' before it, and a full stop (period) after it.
505			* This function will also strip all trailing non alphanumeric characters.
506			* It does not insert an oxford comma.
507			*/
508
509	root	1.9	void
510			make_list_like (char *input)
511			{
512			char *p, tmp[MAX_BUF];
513			int i;
514
515			if (!input \|\| strlen (input) > MAX_BUF - 5)
516	elmex	1.1	return;
517	root	1.9	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
518
519			strncpy (tmp, input, MAX_BUF - 5);
520			/trim all trailing commas, spaces etc. /
521			for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
522			tmp[i] = '\0';
523	root	1.11
524	root	1.9	strcat (tmp, ".");
525
526			p = strrchr (tmp, ',');
527			if (p)
528			{
529			*p = '\0';
530			strcpy (input, tmp);
531			p++;
532			strcat (input, " and");
533			strcat (input, p);
534			}
535			else
536			strcpy (input, tmp);
537	root	1.11
538	root	1.9	return;
539	elmex	1.1	}
540	root	1.3
541	root	1.14	/////////////////////////////////////////////////////////////////////////////
542
543	root	1.17	#if 0
544			refcounted *refcounted::rc_first;
545
546			refcounted::refcounted ()
547			{
548			refcnt = 0;
549			rc_next = rc_first;
550			rc_first = this;
551			}
552
553			refcounted::~refcounted ()
554			{
555			assert (!rc_next);
556			assert (!refcnt);
557			}
558			#endif
559
560	root	1.12	void *alloc (int s) throw (std::bad_alloc)
561	root	1.10	{
562	root	1.13	void *p = g_slice_alloc (s);
563
564			if (!p)
565			throw std::bad_alloc ();
566	root	1.4
567	root	1.13	return p;
568	root	1.3	}
569	root	1.11
570			void assign (char dst, const char src, int maxlen)
571			{
572			if (!src)
573			src = "";
574
575			int len = strlen (src);
576
577			if (len >= maxlen - 1)
578			{
579			if (maxlen <= 4)
580			{
581			memset (dst, '.', maxlen - 1);
582			dst [maxlen - 1] = 0;
583			}
584			else
585			{
586			memcpy (dst, src, maxlen - 4);
587			memcpy (dst + maxlen - 4, "...", 4);
588			}
589			}
590			else
591			memcpy (dst, src, len + 1);
592			}
593
594	root	1.17