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>

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