server/common/utils.C

/*
 * This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.
 * 
 * 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 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 Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 * 
 * 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>

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

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

#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 && mt->next; mt = mt->next)
        {
          if (op->materials & mt->material)
            {
              lmt = mt;
              break;
            }
        }

#else
      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;
            }
        }
#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);
      // 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
};


Revision:	1.59
Committed:	Thu Jun 7 19:12:22 2007 UTC (16 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.58:	+0 -68 lines
Log Message:	- new map header boolean "no_reset 1" to deny reset. - allow reset of per-player maps, effectviely implementing player-private dungeons. - re-enabled reset-on-load feature again. - remove fail-safe mechanism that prevented per-player maps from being reset. keep your fingers crossed. - fixed two bugs in archetype finding (archname vs. object name). - singularities no longer crash the server but will log a backtrace now as they are really are fatal.
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.57	* This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.
3	pippijn	1.39	*
4	root	1.57	* 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	pippijn	1.39	*
8	root	1.57	* Crossfire TRT is free software; you can redistribute it and/or modify it
9			* under the terms of the GNU General Public License as published by the Free
10			* Software Foundation; either version 2 of the License, or (at your option)
11			* any later version.
12	pippijn	1.39	*
13	root	1.57	* This program is distributed in the hope that it will be useful, but
14			* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15			* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16			* for more details.
17	pippijn	1.39	*
18	root	1.57	* You should have received a copy of the GNU General Public License along
19			* with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
20			* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21			*
22			* The authors can be reached via e-mail to <crossfire@schmorp.de>
23	pippijn	1.39	*/
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.49	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
48			state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
49			state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
50			state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;
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	root	1.50	tausworthe_random_generator::get_range (uint32_t num)
69	root	1.42	{
70	root	1.50	return (next () * (uint64_t)num) >> 32U;
71	root	1.42	}
72
73			// return a number within (min .. max)
74			int
75			tausworthe_random_generator::get_range (int r_min, int r_max)
76			{
77	root	1.50	return r_min + get_range (max (r_max - r_min + 1, 0));
78	root	1.42	}
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.55	if (r_max < r_min)
101	root	1.9	{
102	root	1.54	LOG (llevError \| logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
103	root	1.41	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	root	1.55	sint64 omin = min;
127			sint64 diff = max - min + 1;
128			int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
129	root	1.9
130	root	1.55	if (diff < 0)
131	root	1.9	{
132	root	1.54	LOG (llevError \| logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
133	root	1.9	return (min); /* avoids a float exception */
134	elmex	1.1	}
135
136	root	1.45	/*
137			* Make a call to get two 32 bit unsigned random numbers, and just to
138			* a little bitshifting.
139	root	1.9	*/
140	root	1.55	sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
141	root	1.9
142			if (op->type != PLAYER)
143			return ((ran % diff) + min);
144
145	root	1.55	int luck = op->stats.luck;
146
147	root	1.45	if (rndm (base) < MIN (10, abs (luck)))
148	root	1.9	{
149			/* we have a winner */
150			((luck > 0) ? (luck = 1) : (luck = -1));
151			diff -= luck;
152			if (diff < 1)
153			return (omin); /check again /
154	root	1.55
155	root	1.9	((goodbad) ? (min += luck) : (diff));
156	elmex	1.1
157	root	1.9	return (MAX (omin, MIN (max, (ran % diff) + min)));
158	elmex	1.1	}
159	root	1.45
160	root	1.55	return ran % diff + min;
161	elmex	1.1	}
162
163			/*
164			* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
165			* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
166			* Generally, op should be the player/caster/hitter requesting the roll,
167			* not the recipient (ie, the poor slob getting hit).
168			* The args are num D size (ie 4d6) [garbled 20010916]
169			*/
170	root	1.9	int
171			die_roll (int num, int size, const object *op, int goodbad)
172			{
173	root	1.55	int min, luck, total, i, gotlucky;
174	root	1.9
175	root	1.55	int diff = size;
176	root	1.9	min = 1;
177			luck = total = gotlucky = 0;
178	root	1.55	int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
179
180	root	1.9	if (size < 2 \|\| diff < 1)
181			{
182			LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
183	root	1.55	return num; /* avoids a float exception */
184	root	1.9	}
185	elmex	1.1
186	root	1.9	if (op->type == PLAYER)
187			luck = op->stats.luck;
188
189			for (i = 0; i < num; i++)
190			{
191	root	1.45	if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
192	root	1.9	{
193			/* we have a winner */
194			gotlucky++;
195			((luck > 0) ? (luck = 1) : (luck = -1));
196			diff -= luck;
197			if (diff < 1)
198			return (num); /check again /
199			((goodbad) ? (min += luck) : (diff));
200	root	1.45	total += MAX (1, MIN (size, rndm (diff) + min));
201	root	1.9	}
202			else
203	root	1.45	total += rndm (size) + 1;
204	elmex	1.1	}
205	root	1.45
206			return total;
207	elmex	1.1	}
208
209			/* convert materialname to materialtype_t */
210
211	root	1.9	materialtype_t *
212	root	1.47	name_to_material (const shstr &name)
213	elmex	1.1	{
214	root	1.47	for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
215			if (name == mt->name)
216			return mt;
217	elmex	1.1
218	root	1.47	return materialt;
219	elmex	1.1	}
220
221			/* when doing transmutation of objects, we have to recheck the resistances,
222			* as some that did not apply previously, may apply now.
223			*/
224
225	root	1.9	void
226			transmute_materialname (object op, const object change)
227	elmex	1.1	{
228	root	1.9	materialtype_t *mt;
229			int j;
230	elmex	1.1
231	root	1.9	if (op->materialname == NULL)
232			return;
233	elmex	1.1
234	root	1.9	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
235			return;
236
237	root	1.26	if (!op->is_armor ())
238	root	1.9	return;
239
240			mt = name_to_material (op->materialname);
241			if (!mt)
242			{
243	root	1.58	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
244	root	1.9	return;
245			}
246
247			for (j = 0; j < NROFATTACKS; j++)
248			if (op->resist[j] == 0 && change->resist[j] != 0)
249			{
250			op->resist[j] += mt->mod[j];
251			if (op->resist[j] > 100)
252			op->resist[j] = 100;
253			if (op->resist[j] < -100)
254			op->resist[j] = -100;
255			}
256	elmex	1.1	}
257
258			/* set the materialname and type for an item */
259	root	1.9	void
260			set_materialname (object op, int difficulty, materialtype_t nmt)
261	elmex	1.1	{
262	root	1.9	materialtype_t mt, lmt;
263
264	pippijn	1.5	#ifdef NEW_MATERIAL_CODE
265	root	1.9	int j;
266	pippijn	1.5	#endif
267	elmex	1.1
268	root	1.9	if (op->materialname != NULL)
269			return;
270	elmex	1.1
271
272
273	root	1.9	if (nmt == NULL)
274			{
275			lmt = NULL;
276	elmex	1.1	#ifndef NEW_MATERIAL_CODE
277	root	1.47	for (mt = materialt; mt && mt->next; mt = mt->next)
278	root	1.9	{
279	root	1.47	if (op->materials & mt->material)
280	root	1.9	{
281			lmt = mt;
282			break;
283	root	1.2	}
284			}
285	elmex	1.1
286			#else
287	root	1.47	for (mt = materialt; mt && mt->next; mt = mt->next)
288	root	1.9	{
289	root	1.47	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
290	root	1.9	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
291			{
292			lmt = mt;
293	root	1.26	if (!(op->is_weapon () \|\| op->is_armor ()))
294	root	1.9	break;
295	root	1.2	}
296			}
297	elmex	1.1	#endif
298	root	1.9	}
299			else
300			{
301			lmt = nmt;
302	elmex	1.1	}
303
304	root	1.9	if (lmt != NULL)
305			{
306	elmex	1.1	#ifndef NEW_MATERIAL_CODE
307	root	1.9	op->materialname = lmt->name;
308			return;
309	elmex	1.1	#else
310
311	root	1.26	if (op->stats.dam && op->is_weapon ())
312	root	1.9	{
313			op->stats.dam += lmt->damage;
314			if (op->stats.dam < 1)
315			op->stats.dam = 1;
316			}
317	root	1.46
318	root	1.9	if (op->stats.sp && op->type == BOW)
319			op->stats.sp += lmt->sp;
320	root	1.26	if (op->stats.wc && op->is_weapon ())
321	root	1.9	op->stats.wc += lmt->wc;
322	root	1.26	if (op->is_armor ())
323	root	1.9	{
324			if (op->stats.ac)
325			op->stats.ac += lmt->ac;
326			for (j = 0; j < NROFATTACKS; j++)
327			if (op->resist[j] != 0)
328			{
329			op->resist[j] += lmt->mod[j];
330			if (op->resist[j] > 100)
331			op->resist[j] = 100;
332			if (op->resist[j] < -100)
333			op->resist[j] = -100;
334			}
335			}
336	root	1.46	op->materialname = lmt->name;
337	root	1.9	/* dont make it unstackable if it doesn't need to be */
338	root	1.26	if (op->is_weapon () \|\| op->is_armor ())
339	root	1.9	{
340			op->weight = (op->weight * lmt->weight) / 100;
341			op->value = (op->value * lmt->value) / 100;
342	root	1.2	}
343	elmex	1.1	#endif
344			}
345			}
346
347			/*
348			* Strip out the media tags from a String.
349			* Warning the input string will contain the result string
350			*/
351	root	1.9	void
352			strip_media_tag (char *message)
353			{
354			int in_tag = 0;
355			char *dest;
356			char *src;
357
358			src = dest = message;
359			while (*src != '\0')
360			{
361			if (*src == '[')
362			{
363			in_tag = 1;
364			}
365			else if (in_tag && (*src == ']'))
366			in_tag = 0;
367			else if (!in_tag)
368			{
369			dest = src;
370			dest++;
371			}
372			src++;
373			}
374			*dest = '\0';
375			}
376
377			const char *
378			strrstr (const char haystack, const char needle)
379			{
380			const char *lastneedle;
381
382			lastneedle = NULL;
383			while ((haystack = strstr (haystack, needle)) != NULL)
384			{
385			lastneedle = haystack;
386			haystack++;
387	elmex	1.1	}
388	root	1.9	return lastneedle;
389
390	elmex	1.1	}
391	root	1.9
392	elmex	1.1	#define EOL_SIZE (sizeof("\n")-1)
393	root	1.9	void
394			strip_endline (char *buf)
395			{
396			if (strlen (buf) < sizeof ("\n"))
397			{
398			return;
399	elmex	1.1	}
400	root	1.9	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
401			buf[strlen (buf) - EOL_SIZE] = '\0';
402	elmex	1.1	}
403
404			/**
405			* Replace in string src all occurrences of key by replacement. The resulting
406			* string is put into result; at most resultsize characters (including the
407			* terminating null character) will be written to result.
408			*/
409	root	1.9	void
410			replace (const char src, const char key, const char replacement, char result, size_t resultsize)
411	elmex	1.1	{
412	root	1.9	size_t resultlen;
413			size_t keylen;
414	elmex	1.1
415	root	1.9	/* special case to prevent infinite loop if key==replacement=="" */
416			if (strcmp (key, replacement) == 0)
417			{
418			snprintf (result, resultsize, "%s", src);
419			return;
420			}
421
422			keylen = strlen (key);
423
424			resultlen = 0;
425			while (*src != '\0' && resultlen + 1 < resultsize)
426			{
427			if (strncmp (src, key, keylen) == 0)
428	root	1.2	{
429	root	1.9	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
430			resultlen += strlen (result + resultlen);
431			src += keylen;
432	root	1.2	}
433	root	1.9	else
434	root	1.2	{
435	root	1.9	result[resultlen++] = *src++;
436	root	1.2	}
437	root	1.9	}
438			result[resultlen] = '\0';
439	elmex	1.1	}
440
441			/**
442			* Taking a string as an argument, mutate it into a string that looks like a list.
443			* a 'list' for the purposes here, is a string of items, seperated by commas, except
444			* for the last entry, which has an 'and' before it, and a full stop (period) after it.
445			* This function will also strip all trailing non alphanumeric characters.
446			* It does not insert an oxford comma.
447			*/
448
449	root	1.9	void
450			make_list_like (char *input)
451			{
452			char *p, tmp[MAX_BUF];
453			int i;
454
455			if (!input \|\| strlen (input) > MAX_BUF - 5)
456	elmex	1.1	return;
457	root	1.9	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
458
459			strncpy (tmp, input, MAX_BUF - 5);
460			/trim all trailing commas, spaces etc. /
461			for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
462			tmp[i] = '\0';
463	root	1.11
464	root	1.9	strcat (tmp, ".");
465
466			p = strrchr (tmp, ',');
467			if (p)
468			{
469			*p = '\0';
470			strcpy (input, tmp);
471			p++;
472			strcat (input, " and");
473			strcat (input, p);
474			}
475			else
476			strcpy (input, tmp);
477	root	1.11
478	root	1.9	return;
479	elmex	1.1	}
480	root	1.3
481	root	1.14	/////////////////////////////////////////////////////////////////////////////
482
483	root	1.37	void
484			fork_abort (const char *msg)
485			{
486			if (!fork ())
487			{
488			signal (SIGABRT, SIG_DFL);
489	root	1.52	// try to put corefiles into a subdirectory, if existing, to allow
490			// an administrator to reduce the I/O load.
491			chdir ("cores");
492	root	1.37	abort ();
493			}
494
495	root	1.38	LOG (llevError, "fork abort: %s\n", msg);
496	root	1.37	}
497	root	1.38
498	root	1.25	void *salloc_ (int n) throw (std::bad_alloc)
499	root	1.10	{
500	root	1.44	#ifdef PREFER_MALLOC
501			void *ptr = malloc (n);
502			#else
503	root	1.25	void *ptr = g_slice_alloc (n);
504	root	1.44	#endif
505	root	1.13
506	root	1.23	if (!ptr)
507	root	1.13	throw std::bad_alloc ();
508	root	1.4
509	root	1.23	return ptr;
510			}
511
512	root	1.25	void salloc_ (int n, void src) throw (std::bad_alloc)
513	root	1.23	{
514	root	1.25	void *ptr = salloc_ (n);
515	root	1.23
516	root	1.24	if (src)
517	root	1.25	memcpy (ptr, src, n);
518	root	1.24	else
519	root	1.25	memset (ptr, 0, n);
520	root	1.23
521			return ptr;
522	root	1.3	}
523	root	1.11
524			void assign (char dst, const char src, int maxlen)
525			{
526			if (!src)
527			src = "";
528
529			int len = strlen (src);
530
531			if (len >= maxlen - 1)
532			{
533			if (maxlen <= 4)
534			{
535			memset (dst, '.', maxlen - 1);
536			dst [maxlen - 1] = 0;
537			}
538			else
539			{
540			memcpy (dst, src, maxlen - 4);
541			memcpy (dst + maxlen - 4, "...", 4);
542			}
543			}
544			else
545			memcpy (dst, src, len + 1);
546			}
547
548	root	1.51	const std::string
549			format (const char *format, ...)
550			{
551			int len;
552
553			{
554			char buf[128];
555
556			va_list ap;
557			va_start (ap, format);
558			len = vsnprintf (buf, sizeof (buf), format, ap);
559			va_end (ap);
560
561			assert (len >= 0); // shield againstz broken vsnprintf's
562
563			// was our static buffer short enough?
564			if (len < sizeof (buf))
565			return std::string (buf, len);
566			}
567
568			{
569			// longer, try harder
570			char *buf = salloc<char> (len + 1);
571
572			va_list ap;
573			va_start (ap, format);
574			vsnprintf (buf, len + 1, format, ap);
575			va_end (ap);
576
577			const std::string s (buf, len);
578			sfree<char> (buf, len + 1);
579
580			return buf;
581			}
582			}
583
584	root	1.23	tstamp now ()
585			{
586			struct timeval tv;
587
588			gettimeofday (&tv, 0);
589			return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
590			}
591	root	1.17
592	root	1.32	int
593			similar_direction (int a, int b)
594			{
595			if (!a \|\| !b)
596			return 0;
597
598			int diff = (b - a) & 7;
599			return diff <= 1 \|\| diff >= 7;
600			}
601
602	root	1.48	/* crc32 0xdebb20e3 table and supplementary functions. */
603			extern const uint32_t crc_32_tab[256] =
604			{
605			0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
606			0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
607			0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
608			0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
609			0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
610			0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
611			0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
612			0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
613			0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
614			0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
615			0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
616			0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
617			0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
618			0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
619			0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
620			0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
621			0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
622			0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
623			0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
624			0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
625			0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
626			0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
627			0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
628			0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
629			0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
630			0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
631			0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
632			0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
633			0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
634			0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
635			0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
636			0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
637			0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
638			0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
639			0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
640			0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
641			0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
642			0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
643			0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
644			0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
645			0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
646			0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
647			0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
648			0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
649			0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
650			0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
651			0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
652			0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
653			0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
654			0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
655			0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
656			0x2d02ef8dL
657			};
658
659