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>

rand_gen rndm;

void
tausworthe_random_generator::seed (uint32_t seed)
{
  state [0] = max (  2U, seed      * 69069U);
  state [1] = max (  8U, state [0] * 69069U);
  state [2] = max ( 16U, state [1] * 69069U);
  state [3] = max (128U, state [2] * 69069U);

  for (int i = 11; --i; )
    operator ()();
}

uint32_t
tausworthe_random_generator::next ()
{
  state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] <<  6U) ^ state [0]) >> 13U);
  state [1] = ((state [1] & 0xFFFFFFF8U) <<  2U) ^ (((state [1] <<  2U) ^ state [1]) >> 27U);
  state [2] = ((state [2] & 0xFFFFFFF0U) <<  7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
  state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] <<  3U) ^ state [3]) >> 12U);

  return state [0] ^ state [1] ^ state [2] ^ state [3];
}

uint32_t
tausworthe_random_generator::get_range (uint32_t r_max)
{
  return next () % r_max;
}

// return a number within (min .. max)
int 
tausworthe_random_generator::get_range (int r_min, int r_max)
{
  return r_min + (*this) (max (r_max - r_min + 1, 1));
}

/*
 * 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 r_min, int r_max, const object *op, int goodbad)
{
  int base = r_max - r_min > 1 ? 20 : 50;     /* d2 and d3 are corner cases */

  if (r_max < 1 || r_max < r_min)
    {
      LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
      return r_min;
    }

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

      if (rndm (base) < min (10, abs (luck)))
        {
          //TODO: take luck into account
        }
    }

  return rndm (r_min, r_max);
}

/*
 * 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 */
    }

  /* 
   * Make a call to get two 32 bit unsigned random numbers, and just to
   * a little bitshifting.
   */
  ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);

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

  luck = op->stats.luck;
  if (rndm (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;

  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 (rndm (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));
          total += MAX (1, MIN (size, rndm (diff) + min));
        }
      else
        total += rndm (size) + 1;
    }

  return total;
}

/* 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)
{
  if (!fork ())
    {
      signal (SIGABRT, SIG_DFL);
      abort ();
    }

  LOG (llevError, "fork abort: %s\n", msg);
}

void *salloc_ (int n) throw (std::bad_alloc)
{
#ifdef PREFER_MALLOC
  void *ptr = malloc (n);
#else
  void *ptr = g_slice_alloc (n);
#endif

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