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 = 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.46
Committed:	Mon Feb 5 01:47:22 2007 UTC (17 years, 3 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.45:	+2 -1 lines
Log Message:	fix dead code to confuse me less
#	User	Rev	Content
1	elmex	1.1	/*
2	pippijn	1.39	* 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	elmex	1.1
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	root	1.42	rand_gen rndm;
43	root	1.40
44	root	1.42	void
45			tausworthe_random_generator::seed (uint32_t seed)
46	root	1.40	{
47	root	1.43	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	root	1.40
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	root	1.42	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	elmex	1.1	/*
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	root	1.9	int
96	root	1.41	random_roll (int r_min, int r_max, const object *op, int goodbad)
97	root	1.9	{
98	root	1.41	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
99	elmex	1.1
100	root	1.41	if (r_max < 1 \|\| r_max < r_min)
101	root	1.9	{
102	root	1.41	LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
103			return r_min;
104	elmex	1.1	}
105
106	root	1.41	if (op->type == PLAYER)
107	root	1.9	{
108	root	1.41	int luck = op->stats.luck;
109	elmex	1.1
110	root	1.41	if (rndm (base) < min (10, abs (luck)))
111			{
112			//TODO: take luck into account
113			}
114	elmex	1.1	}
115	root	1.41
116			return rndm (r_min, r_max);
117	elmex	1.1	}
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	root	1.9	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	elmex	1.1
133	root	1.9	if (max < 1 \|\| diff < 1)
134			{
135	root	1.20	LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
136	root	1.9	return (min); /* avoids a float exception */
137	elmex	1.1	}
138
139	root	1.45	/*
140			* Make a call to get two 32 bit unsigned random numbers, and just to
141			* a little bitshifting.
142	root	1.9	*/
143	root	1.45	ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
144	root	1.9
145			if (op->type != PLAYER)
146			return ((ran % diff) + min);
147
148			luck = op->stats.luck;
149	root	1.45	if (rndm (base) < MIN (10, abs (luck)))
150	root	1.9	{
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	elmex	1.1
158	root	1.9	return (MAX (omin, MIN (max, (ran % diff) + min)));
159	elmex	1.1	}
160	root	1.45
161	root	1.9	return ((ran % diff) + min);
162	elmex	1.1	}
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	root	1.9	int
173			die_roll (int num, int size, const object *op, int goodbad)
174			{
175	root	1.45	int min, diff, luck, total, i, gotlucky, base;
176	root	1.9
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	elmex	1.1
187	root	1.9	if (op->type == PLAYER)
188			luck = op->stats.luck;
189
190			for (i = 0; i < num; i++)
191			{
192	root	1.45	if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
193	root	1.9	{
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	root	1.45	total += MAX (1, MIN (size, rndm (diff) + min));
202	root	1.9	}
203			else
204	root	1.45	total += rndm (size) + 1;
205	elmex	1.1	}
206	root	1.45
207			return total;
208	elmex	1.1	}
209
210	root	1.33	/* decay and destroy perishable items in a map */
211	root	1.9	void
212	root	1.32	maptile::decay_objects ()
213	elmex	1.1	{
214	root	1.35	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	root	1.32
224	root	1.35	// 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	root	1.32
228	root	1.35	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	elmex	1.1	}
277
278			/* convert materialname to materialtype_t */
279
280	root	1.9	materialtype_t *
281			name_to_material (const char *name)
282	elmex	1.1	{
283	root	1.9	materialtype_t mt, nmt;
284	elmex	1.1
285	root	1.9	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	root	1.2	}
293	elmex	1.1	}
294	root	1.9	return mt;
295	elmex	1.1	}
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	root	1.9	void
302			transmute_materialname (object op, const object change)
303	elmex	1.1	{
304	root	1.9	materialtype_t *mt;
305			int j;
306	elmex	1.1
307	root	1.9	if (op->materialname == NULL)
308			return;
309	elmex	1.1
310	root	1.9	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
311			return;
312
313	root	1.26	if (!op->is_armor ())
314	root	1.9	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	elmex	1.1	}
333
334			/* set the materialname and type for an item */
335	root	1.9	void
336			set_materialname (object op, int difficulty, materialtype_t nmt)
337	elmex	1.1	{
338	root	1.9	materialtype_t mt, lmt;
339
340	pippijn	1.5	#ifdef NEW_MATERIAL_CODE
341	root	1.9	int j;
342	pippijn	1.5	#endif
343	elmex	1.1
344	root	1.9	if (op->materialname != NULL)
345			return;
346	elmex	1.1
347
348
349	root	1.9	if (nmt == NULL)
350			{
351			lmt = NULL;
352	elmex	1.1	#ifndef NEW_MATERIAL_CODE
353	root	1.9	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	root	1.2	}
360			}
361	elmex	1.1
362			#else
363	root	1.9	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	root	1.26	if (!(op->is_weapon () \|\| op->is_armor ()))
370	root	1.9	break;
371	root	1.2	}
372			}
373	elmex	1.1	#endif
374	root	1.9	}
375			else
376			{
377			lmt = nmt;
378	elmex	1.1	}
379
380	root	1.9	if (lmt != NULL)
381			{
382	elmex	1.1	#ifndef NEW_MATERIAL_CODE
383	root	1.9	op->materialname = lmt->name;
384			return;
385	elmex	1.1	#else
386
387	root	1.26	if (op->stats.dam && op->is_weapon ())
388	root	1.9	{
389			op->stats.dam += lmt->damage;
390			if (op->stats.dam < 1)
391			op->stats.dam = 1;
392			}
393	root	1.46
394	root	1.9	if (op->stats.sp && op->type == BOW)
395			op->stats.sp += lmt->sp;
396	root	1.26	if (op->stats.wc && op->is_weapon ())
397	root	1.9	op->stats.wc += lmt->wc;
398	root	1.26	if (op->is_armor ())
399	root	1.9	{
400			if (op->stats.ac)
401			op->stats.ac += lmt->ac;
402			for (j = 0; j < NROFATTACKS; j++)
403			if (op->resist[j] != 0)
404			{
405			op->resist[j] += lmt->mod[j];
406			if (op->resist[j] > 100)
407			op->resist[j] = 100;
408			if (op->resist[j] < -100)
409			op->resist[j] = -100;
410			}
411			}
412	root	1.46	op->materialname = lmt->name;
413	root	1.9	/* dont make it unstackable if it doesn't need to be */
414	root	1.26	if (op->is_weapon () \|\| op->is_armor ())
415	root	1.9	{
416			op->weight = (op->weight * lmt->weight) / 100;
417			op->value = (op->value * lmt->value) / 100;
418	root	1.2	}
419	elmex	1.1	#endif
420			}
421			}
422
423			/*
424			* Strip out the media tags from a String.
425			* Warning the input string will contain the result string
426			*/
427	root	1.9	void
428			strip_media_tag (char *message)
429			{
430			int in_tag = 0;
431			char *dest;
432			char *src;
433
434			src = dest = message;
435			while (*src != '\0')
436			{
437			if (*src == '[')
438			{
439			in_tag = 1;
440			}
441			else if (in_tag && (*src == ']'))
442			in_tag = 0;
443			else if (!in_tag)
444			{
445			dest = src;
446			dest++;
447			}
448			src++;
449			}
450			*dest = '\0';
451			}
452
453			const char *
454			strrstr (const char haystack, const char needle)
455			{
456			const char *lastneedle;
457
458			lastneedle = NULL;
459			while ((haystack = strstr (haystack, needle)) != NULL)
460			{
461			lastneedle = haystack;
462			haystack++;
463	elmex	1.1	}
464	root	1.9	return lastneedle;
465
466	elmex	1.1	}
467	root	1.9
468	elmex	1.1	#define EOL_SIZE (sizeof("\n")-1)
469	root	1.9	void
470			strip_endline (char *buf)
471			{
472			if (strlen (buf) < sizeof ("\n"))
473			{
474			return;
475	elmex	1.1	}
476	root	1.9	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
477			buf[strlen (buf) - EOL_SIZE] = '\0';
478	elmex	1.1	}
479
480			/**
481			* Replace in string src all occurrences of key by replacement. The resulting
482			* string is put into result; at most resultsize characters (including the
483			* terminating null character) will be written to result.
484			*/
485	root	1.9	void
486			replace (const char src, const char key, const char replacement, char result, size_t resultsize)
487	elmex	1.1	{
488	root	1.9	size_t resultlen;
489			size_t keylen;
490	elmex	1.1
491	root	1.9	/* special case to prevent infinite loop if key==replacement=="" */
492			if (strcmp (key, replacement) == 0)
493			{
494			snprintf (result, resultsize, "%s", src);
495			return;
496			}
497
498			keylen = strlen (key);
499
500			resultlen = 0;
501			while (*src != '\0' && resultlen + 1 < resultsize)
502			{
503			if (strncmp (src, key, keylen) == 0)
504	root	1.2	{
505	root	1.9	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
506			resultlen += strlen (result + resultlen);
507			src += keylen;
508	root	1.2	}
509	root	1.9	else
510	root	1.2	{
511	root	1.9	result[resultlen++] = *src++;
512	root	1.2	}
513	root	1.9	}
514			result[resultlen] = '\0';
515	elmex	1.1	}
516
517			/**
518			* Taking a string as an argument, mutate it into a string that looks like a list.
519			* a 'list' for the purposes here, is a string of items, seperated by commas, except
520			* for the last entry, which has an 'and' before it, and a full stop (period) after it.
521			* This function will also strip all trailing non alphanumeric characters.
522			* It does not insert an oxford comma.
523			*/
524
525	root	1.9	void
526			make_list_like (char *input)
527			{
528			char *p, tmp[MAX_BUF];
529			int i;
530
531			if (!input \|\| strlen (input) > MAX_BUF - 5)
532	elmex	1.1	return;
533	root	1.9	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
534
535			strncpy (tmp, input, MAX_BUF - 5);
536			/trim all trailing commas, spaces etc. /
537			for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
538			tmp[i] = '\0';
539	root	1.11
540	root	1.9	strcat (tmp, ".");
541
542			p = strrchr (tmp, ',');
543			if (p)
544			{
545			*p = '\0';
546			strcpy (input, tmp);
547			p++;
548			strcat (input, " and");
549			strcat (input, p);
550			}
551			else
552			strcpy (input, tmp);
553	root	1.11
554	root	1.9	return;
555	elmex	1.1	}
556	root	1.3
557	root	1.14	/////////////////////////////////////////////////////////////////////////////
558
559	root	1.37	void
560			fork_abort (const char *msg)
561			{
562			if (!fork ())
563			{
564			signal (SIGABRT, SIG_DFL);
565			abort ();
566			}
567
568	root	1.38	LOG (llevError, "fork abort: %s\n", msg);
569	root	1.37	}
570	root	1.38
571	root	1.25	void *salloc_ (int n) throw (std::bad_alloc)
572	root	1.10	{
573	root	1.44	#ifdef PREFER_MALLOC
574			void *ptr = malloc (n);
575			#else
576	root	1.25	void *ptr = g_slice_alloc (n);
577	root	1.44	#endif
578	root	1.13
579	root	1.23	if (!ptr)
580	root	1.13	throw std::bad_alloc ();
581	root	1.4
582	root	1.23	return ptr;
583			}
584
585	root	1.25	void salloc_ (int n, void src) throw (std::bad_alloc)
586	root	1.23	{
587	root	1.25	void *ptr = salloc_ (n);
588	root	1.23
589	root	1.24	if (src)
590	root	1.25	memcpy (ptr, src, n);
591	root	1.24	else
592	root	1.25	memset (ptr, 0, n);
593	root	1.23
594			return ptr;
595	root	1.3	}
596	root	1.11
597			void assign (char dst, const char src, int maxlen)
598			{
599			if (!src)
600			src = "";
601
602			int len = strlen (src);
603
604			if (len >= maxlen - 1)
605			{
606			if (maxlen <= 4)
607			{
608			memset (dst, '.', maxlen - 1);
609			dst [maxlen - 1] = 0;
610			}
611			else
612			{
613			memcpy (dst, src, maxlen - 4);
614			memcpy (dst + maxlen - 4, "...", 4);
615			}
616			}
617			else
618			memcpy (dst, src, len + 1);
619			}
620
621	root	1.23	tstamp now ()
622			{
623			struct timeval tv;
624
625			gettimeofday (&tv, 0);
626			return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
627			}
628	root	1.17
629	root	1.32	int
630			similar_direction (int a, int b)
631			{
632			if (!a \|\| !b)
633			return 0;
634
635			int diff = (b - a) & 7;
636			return diff <= 1 \|\| diff >= 7;
637			}
638