server/common/utils.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <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>

refcnt_base::refcnt_t refcnt_dummy;

rand_gen rndm;

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

  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 num)
{
  return (next () * (uint64_t)num) >> 32U;
}

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

/*
 * 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 < r_min)
    {
      LOG (llevError | logBacktrace, "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 = min;
  sint64 diff = max - min + 1;
  int base = diff > 2 ? 20 : 50;     /* d2 and d3 are corner cases */

  if (diff < 0)
    {
      LOG (llevError | logBacktrace, "Calling random_roll64 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.
   */
  sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);

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

  int 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, luck, total, i, gotlucky;

  int diff = size;
  min = 1;
  luck = total = gotlucky = 0;
  int base = diff > 2 ? 20 : 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;
}

/* convert materialname to materialtype_t */

materialtype_t *
name_to_material (const shstr &name)
{
  for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
    if (name == mt->name)
      return mt;

  return 0;
}

/* 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->archname, &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;

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

  if (nmt == NULL)
    {
      lmt = NULL;

      for (mt = materialt; mt && mt->next; mt = mt->next)
        if (op->materials & 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;
          }
    }
  else
    lmt = nmt;

  if (lmt != NULL)
    {
      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 (int 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;
        }
    }
}

/*
 * 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);
      // try to put corefiles into a subdirectory, if existing, to allow
      // an administrator to reduce the I/O load.
      chdir ("cores");
      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);
}

const std::string
format (const char *format, ...)
{
  int len;

  {
    char buf[128];

    va_list ap;
    va_start (ap, format);
    len = vsnprintf (buf, sizeof (buf), format, ap);
    va_end (ap);

    assert (len >= 0); // shield againstz broken vsnprintf's

    // was our static buffer short enough?
    if (len < sizeof (buf))
      return std::string (buf, len);
  }

  {
    // longer, try harder
    char *buf = salloc<char> (len + 1);

    va_list ap;
    va_start (ap, format);
    vsnprintf (buf, len + 1, format, ap);
    va_end (ap);

    const std::string s (buf, len);
    sfree<char> (buf, len + 1);
      
    return buf;
  }
}

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

/* crc32 0xdebb20e3 table and supplementary functions.  */
extern const uint32_t crc_32_tab[256] =
{
    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
    0x2d02ef8dL
};

#if 0
void xyzzy (object_ptr &a, object_ptr &o)
{
  asm volatile ("int3");
  a = o;
  asm volatile ("int3");
}
#endif

Revision:	1.63
Committed:	Mon Aug 6 10:54:11 2007 UTC (16 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.62:	+10 -0 lines
Log Message:	rather uncertain optimisation.. trying to take advantage of cmov instructions if refptr. a = b before: 510: 48 8b 16 mov (%rsi),%rdx 513: 48 85 d2 test %rdx,%rdx 516: 75 0c jne 524 <xyzzy(refptr<object>, refptr<object>)+0x14> 518: 48 8b 07 mov (%rdi),%rax 51b: 48 85 c0 test %rax,%rax 51e: 75 09 jne 529 <xyzzy(refptr<object>, refptr<object>)+0x19> 520: 48 89 17 mov %rdx,(%rdi) 523: c3 retq 524: ff 42 08 incl 0x8(%rdx) 527: eb ef jmp 518 <xyzzy(refptr<object>, refptr<object>)+0x8> 529: ff 48 08 decl 0x8(%rax) 52c: 0f 1f 40 00 nopl 0x0(%rax) 530: eb ee jmp 520 <xyzzy(refptr<object>, refptr<object>)+0x10> a = b after: 141: 4c 8b 0f mov (%rdi),%r9 144: ba 00 00 00 00 mov $0x0,%edx 149: 4d 8d 41 08 lea 0x8(%r9),%r8 14d: 4d 85 c9 test %r9,%r9 150: 4c 0f 44 c2 cmove %rdx,%r8 154: 41 ff 08 decl (%r8) 157: 48 8b 06 mov (%rsi),%rax 15a: 48 8d 48 08 lea 0x8(%rax),%rcx 15e: 48 85 c0 test %rax,%rax 161: 48 89 07 mov %rax,(%rdi) 164: 48 0f 45 d1 cmovne %rcx,%rdx 168: ff 02 incl (%rdx) 16a: c3 retq note no jumps but larger codeside (1.7kb net increase).
#	Content
1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/
23
24	/*
25	* General convenience functions for crossfire.
26	*/
27
28	#include <cstdlib>
29	#include <sys/types.h>
30	#include <unistd.h>
31	#include <sys/time.h>
32	#include <time.h>
33	#include <signal.h>
34
35	#include <global.h>
36	#include <funcpoint.h>
37	#include <material.h>
38
39	#include <glib.h>
40
41	refcnt_base::refcnt_t refcnt_dummy;
42
43	rand_gen rndm;
44
45	void
46	tausworthe_random_generator::seed (uint32_t seed)
47	{
48	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
49	state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
50	state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
51	state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;
52
53	for (int i = 11; --i; )
54	operator ()();
55	}
56
57	uint32_t
58	tausworthe_random_generator::next ()
59	{
60	state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] << 6U) ^ state [0]) >> 13U);
61	state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U);
62	state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
63	state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
64
65	return state [0] ^ state [1] ^ state [2] ^ state [3];
66	}
67
68	uint32_t
69	tausworthe_random_generator::get_range (uint32_t num)
70	{
71	return (next () * (uint64_t)num) >> 32U;
72	}
73
74	// return a number within (min .. max)
75	int
76	tausworthe_random_generator::get_range (int r_min, int r_max)
77	{
78	return r_min + get_range (max (r_max - r_min + 1, 0));
79	}
80
81	/*
82	* The random functions here take luck into account when rolling random
83	* dice or numbers. This function has less of an impact the larger the
84	* difference becomes in the random numbers. IE, the effect is lessened
85	* on a 1-1000 roll, vs a 1-6 roll. This can be used by crafty programmers,
86	* to specifically disable luck in certain rolls, simply by making the
87	* numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)
88	*/
89
90	/*
91	* Roll a random number between min and max. Uses op to determine luck,
92	* and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
93	* Generally, op should be the player/caster/hitter requesting the roll,
94	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
95	*/
96	int
97	random_roll (int r_min, int r_max, const object *op, int goodbad)
98	{
99	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
100
101	if (r_max < r_min)
102	{
103	LOG (llevError \| logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
104	return r_min;
105	}
106
107	if (op->type == PLAYER)
108	{
109	int luck = op->stats.luck;
110
111	if (rndm (base) < min (10, abs (luck)))
112	{
113	//TODO: take luck into account
114	}
115	}
116
117	return rndm (r_min, r_max);
118	}
119
120	/*
121	* This is a 64 bit version of random_roll above. This is needed
122	* for exp loss calculations for players changing religions.
123	*/
124	sint64
125	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
126	{
127	sint64 omin = min;
128	sint64 diff = max - min + 1;
129	int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
130
131	if (diff < 0)
132	{
133	LOG (llevError \| logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
134	return (min); /* avoids a float exception */
135	}
136
137	/*
138	* Make a call to get two 32 bit unsigned random numbers, and just to
139	* a little bitshifting.
140	*/
141	sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
142
143	if (op->type != PLAYER)
144	return ((ran % diff) + min);
145
146	int luck = op->stats.luck;
147
148	if (rndm (base) < MIN (10, abs (luck)))
149	{
150	/* we have a winner */
151	((luck > 0) ? (luck = 1) : (luck = -1));
152	diff -= luck;
153	if (diff < 1)
154	return (omin); /check again /
155
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	int
172	die_roll (int num, int size, const object *op, int goodbad)
173	{
174	int min, luck, total, i, gotlucky;
175
176	int diff = size;
177	min = 1;
178	luck = total = gotlucky = 0;
179	int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
180
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	/* convert materialname to materialtype_t */
211
212	materialtype_t *
213	name_to_material (const shstr &name)
214	{
215	for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
216	if (name == mt->name)
217	return mt;
218
219	return 0;
220	}
221
222	/* when doing transmutation of objects, we have to recheck the resistances,
223	* as some that did not apply previously, may apply now.
224	*/
225
226	void
227	transmute_materialname (object op, const object change)
228	{
229	materialtype_t *mt;
230	int j;
231
232	if (op->materialname == NULL)
233	return;
234
235	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
236	return;
237
238	if (!op->is_armor ())
239	return;
240
241	mt = name_to_material (op->materialname);
242	if (!mt)
243	{
244	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
245	return;
246	}
247
248	for (j = 0; j < NROFATTACKS; j++)
249	if (op->resist[j] == 0 && change->resist[j] != 0)
250	{
251	op->resist[j] += mt->mod[j];
252	if (op->resist[j] > 100)
253	op->resist[j] = 100;
254	if (op->resist[j] < -100)
255	op->resist[j] = -100;
256	}
257	}
258
259	/* set the materialname and type for an item */
260	void
261	set_materialname (object op, int difficulty, materialtype_t nmt)
262	{
263	materialtype_t mt, lmt;
264
265	if (op->materialname != NULL)
266	return;
267
268	if (nmt == NULL)
269	{
270	lmt = NULL;
271
272	for (mt = materialt; mt && mt->next; mt = mt->next)
273	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
274	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
275	{
276	lmt = mt;
277	if (!(op->is_weapon () \|\| op->is_armor ()))
278	break;
279	}
280	}
281	else
282	lmt = nmt;
283
284	if (lmt != NULL)
285	{
286	if (op->stats.dam && op->is_weapon ())
287	{
288	op->stats.dam += lmt->damage;
289	if (op->stats.dam < 1)
290	op->stats.dam = 1;
291	}
292
293	if (op->stats.sp && op->type == BOW)
294	op->stats.sp += lmt->sp;
295	if (op->stats.wc && op->is_weapon ())
296	op->stats.wc += lmt->wc;
297	if (op->is_armor ())
298	{
299	if (op->stats.ac)
300	op->stats.ac += lmt->ac;
301
302	for (int j = 0; j < NROFATTACKS; j++)
303	if (op->resist[j] != 0)
304	{
305	op->resist[j] += lmt->mod[j];
306	if (op->resist[j] > 100)
307	op->resist[j] = 100;
308	if (op->resist[j] < -100)
309	op->resist[j] = -100;
310	}
311	}
312
313	op->materialname = lmt->name;
314	/* dont make it unstackable if it doesn't need to be */
315	if (op->is_weapon () \|\| op->is_armor ())
316	{
317	op->weight = (op->weight * lmt->weight) / 100;
318	op->value = (op->value * lmt->value) / 100;
319	}
320	}
321	}
322
323	/*
324	* Strip out the media tags from a String.
325	* Warning the input string will contain the result string
326	*/
327	void
328	strip_media_tag (char *message)
329	{
330	int in_tag = 0;
331	char *dest;
332	char *src;
333
334	src = dest = message;
335	while (*src != '\0')
336	{
337	if (*src == '[')
338	{
339	in_tag = 1;
340	}
341	else if (in_tag && (*src == ']'))
342	in_tag = 0;
343	else if (!in_tag)
344	{
345	dest = src;
346	dest++;
347	}
348	src++;
349	}
350	*dest = '\0';
351	}
352
353	const char *
354	strrstr (const char haystack, const char needle)
355	{
356	const char *lastneedle;
357
358	lastneedle = NULL;
359	while ((haystack = strstr (haystack, needle)) != NULL)
360	{
361	lastneedle = haystack;
362	haystack++;
363	}
364	return lastneedle;
365
366	}
367
368	#define EOL_SIZE (sizeof("\n")-1)
369	void
370	strip_endline (char *buf)
371	{
372	if (strlen (buf) < sizeof ("\n"))
373	{
374	return;
375	}
376	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
377	buf[strlen (buf) - EOL_SIZE] = '\0';
378	}
379
380	/**
381	* Replace in string src all occurrences of key by replacement. The resulting
382	* string is put into result; at most resultsize characters (including the
383	* terminating null character) will be written to result.
384	*/
385	void
386	replace (const char src, const char key, const char replacement, char result, size_t resultsize)
387	{
388	size_t resultlen;
389	size_t keylen;
390
391	/* special case to prevent infinite loop if key==replacement=="" */
392	if (strcmp (key, replacement) == 0)
393	{
394	snprintf (result, resultsize, "%s", src);
395	return;
396	}
397
398	keylen = strlen (key);
399
400	resultlen = 0;
401	while (*src != '\0' && resultlen + 1 < resultsize)
402	{
403	if (strncmp (src, key, keylen) == 0)
404	{
405	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
406	resultlen += strlen (result + resultlen);
407	src += keylen;
408	}
409	else
410	{
411	result[resultlen++] = *src++;
412	}
413	}
414	result[resultlen] = '\0';
415	}
416
417	/**
418	* Taking a string as an argument, mutate it into a string that looks like a list.
419	* a 'list' for the purposes here, is a string of items, seperated by commas, except
420	* for the last entry, which has an 'and' before it, and a full stop (period) after it.
421	* This function will also strip all trailing non alphanumeric characters.
422	* It does not insert an oxford comma.
423	*/
424
425	void
426	make_list_like (char *input)
427	{
428	char *p, tmp[MAX_BUF];
429	int i;
430
431	if (!input \|\| strlen (input) > MAX_BUF - 5)
432	return;
433	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
434
435	strncpy (tmp, input, MAX_BUF - 5);
436	/trim all trailing commas, spaces etc. /
437	for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
438	tmp[i] = '\0';
439
440	strcat (tmp, ".");
441
442	p = strrchr (tmp, ',');
443	if (p)
444	{
445	*p = '\0';
446	strcpy (input, tmp);
447	p++;
448	strcat (input, " and");
449	strcat (input, p);
450	}
451	else
452	strcpy (input, tmp);
453
454	return;
455	}
456
457	/////////////////////////////////////////////////////////////////////////////
458
459	void
460	fork_abort (const char *msg)
461	{
462	if (!fork ())
463	{
464	signal (SIGABRT, SIG_DFL);
465	// try to put corefiles into a subdirectory, if existing, to allow
466	// an administrator to reduce the I/O load.
467	chdir ("cores");
468	abort ();
469	}
470
471	LOG (llevError, "fork abort: %s\n", msg);
472	}
473
474	void *salloc_ (int n) throw (std::bad_alloc)
475	{
476	#ifdef PREFER_MALLOC
477	void *ptr = malloc (n);
478	#else
479	void *ptr = g_slice_alloc (n);
480	#endif
481
482	if (!ptr)
483	throw std::bad_alloc ();
484
485	return ptr;
486	}
487
488	void salloc_ (int n, void src) throw (std::bad_alloc)
489	{
490	void *ptr = salloc_ (n);
491
492	if (src)
493	memcpy (ptr, src, n);
494	else
495	memset (ptr, 0, n);
496
497	return ptr;
498	}
499
500	void assign (char dst, const char src, int maxlen)
501	{
502	if (!src)
503	src = "";
504
505	int len = strlen (src);
506
507	if (len >= maxlen - 1)
508	{
509	if (maxlen <= 4)
510	{
511	memset (dst, '.', maxlen - 1);
512	dst [maxlen - 1] = 0;
513	}
514	else
515	{
516	memcpy (dst, src, maxlen - 4);
517	memcpy (dst + maxlen - 4, "...", 4);
518	}
519	}
520	else
521	memcpy (dst, src, len + 1);
522	}
523
524	const std::string
525	format (const char *format, ...)
526	{
527	int len;
528
529	{
530	char buf[128];
531
532	va_list ap;
533	va_start (ap, format);
534	len = vsnprintf (buf, sizeof (buf), format, ap);
535	va_end (ap);
536
537	assert (len >= 0); // shield againstz broken vsnprintf's
538
539	// was our static buffer short enough?
540	if (len < sizeof (buf))
541	return std::string (buf, len);
542	}
543
544	{
545	// longer, try harder
546	char *buf = salloc<char> (len + 1);
547
548	va_list ap;
549	va_start (ap, format);
550	vsnprintf (buf, len + 1, format, ap);
551	va_end (ap);
552
553	const std::string s (buf, len);
554	sfree<char> (buf, len + 1);
555
556	return buf;
557	}
558	}
559
560	tstamp now ()
561	{
562	struct timeval tv;
563
564	gettimeofday (&tv, 0);
565	return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
566	}
567
568	int
569	similar_direction (int a, int b)
570	{
571	if (!a \|\| !b)
572	return 0;
573
574	int diff = (b - a) & 7;
575	return diff <= 1 \|\| diff >= 7;
576	}
577
578	/* crc32 0xdebb20e3 table and supplementary functions. */
579	extern const uint32_t crc_32_tab[256] =
580	{
581	0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
582	0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
583	0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
584	0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
585	0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
586	0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
587	0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
588	0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
589	0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
590	0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
591	0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
592	0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
593	0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
594	0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
595	0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
596	0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
597	0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
598	0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
599	0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
600	0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
601	0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
602	0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
603	0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
604	0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
605	0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
606	0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
607	0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
608	0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
609	0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
610	0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
611	0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
612	0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
613	0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
614	0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
615	0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
616	0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
617	0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
618	0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
619	0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
620	0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
621	0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
622	0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
623	0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
624	0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
625	0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
626	0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
627	0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
628	0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
629	0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
630	0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
631	0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
632	0x2d02ef8dL
633	};
634
635	#if 0
636	void xyzzy (object_ptr &a, object_ptr &o)
637	{
638	asm volatile ("int3");
639	a = o;
640	asm volatile ("int3");
641	}
642	#endif
643