server/common/utils.C

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
    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 <cstdlib>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <signal.h>

#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 perishable items in a map */
void
maptile::decay_objects ()
{
  if (!spaces)
    return;

  for (mapspace *ms = spaces + size (); ms-- > spaces; )
    for (object *above, *op = ms->bot; op; op = above)
      {
        above = op->above;

        bool destroy = 0;

        // do not decay anything above unique floor tiles (yet :)
        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 ())
          ; // do not decay
        else 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
          {
            int mat = op->material;

            if (mat & M_PAPER
                || mat & M_LEATHER
                || mat & M_WOOD
                || mat & M_ORGANIC
                || mat & M_CLOTH
                || mat & M_LIQUID
                || (mat & M_IRON  && rndm (1, 5) == 1)
                || (mat & M_GLASS && rndm (1, 2) == 1)
                || ((mat & M_STONE      || mat & M_ADAMANT) && rndm (1, 10) == 1)
                || ((mat & M_SOFT_METAL || mat & M_BONE)    && rndm (1, 3)  == 1)
                || (mat & M_ICE && temp > 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;
}

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

void
fork_abort (const char *msg)
{
  LOG (llevError, "fork abort: %s\n", msg);
  if (!fork ())
    {
      signal (SIGABRT, SIG_DFL);
      abort ();
    }

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

int
similar_direction (int a, int b)
{
  if (!a || !b)
    return 0;

  int diff = (b - a) & 7;
  return diff <= 1 || diff >= 7;
}

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