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 <sys/time.h>
#include <time.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)
              || op->is_alive ())
            continue;

          /* otherwise, we decay and destroy */
          if (op->is_weapon ())
            {
              op->stats.dam--;
              if (op->stats.dam < 0)
                destroy = 1;
            }
          else if (op->is_armor ())
            {
              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 (!op->is_armor ())
    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 (!(op->is_weapon () || op->is_armor ()))
                break;
            }
        }
#endif
    }
  else
    {
      lmt = nmt;
    }

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

      if (op->stats.dam && op->is_weapon ())
        {
          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 && op->is_weapon ())
        op->stats.wc += lmt->wc;
      if (op->is_armor ())
        {
          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 (op->is_weapon () || op->is_armor ())
        {
          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 *salloc_ (int n) throw (std::bad_alloc)
{
  void *ptr = g_slice_alloc (n);

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

  return ptr;
}

void *salloc_ (int n, void *src) throw (std::bad_alloc)
{
  void *ptr = salloc_ (n);

  if (src)
    memcpy (ptr, src, n);
  else
    memset (ptr, 0, n);

  return ptr;
}

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);
}

tstamp now ()
{
  struct timeval tv;

  gettimeofday (&tv, 0);
  return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
}

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