--- deliantra/server/common/utils.C 2009/11/03 23:18:23 1.92 +++ deliantra/server/common/utils.C 2017/01/19 21:51:43 1.105 @@ -1,24 +1,22 @@ /* * This file is part of Deliantra, the Roguelike Realtime MMORPG. - * - * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team - * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team - * Copyright (©) 1992,2007 Frank Tore Johansen - * + * + * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team + * * Deliantra is free software: you can redistribute it and/or modify it under * the terms of the Affero 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 Affero GNU General Public License * and the GNU General Public License along with this program. If not, see * . - * + * * The authors can be reached via e-mail to */ @@ -44,380 +42,30 @@ refcnt_base::refcnt_t refcnt_dummy; ssize_t slice_alloc; -rand_gen rndm, rmg_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] < 128U) state [0] += 128U; - - for (int i = 11; --i; ) - next (); -} - -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]; -} - -template -uint32_t -random_number_generator::get_range (uint32_t num) -{ - return (this->next () * (uint64_t)num) >> 32U; -} - -// return a number within (min .. max) -template -int -random_number_generator::get_range (int r_min, int r_max) -{ - return r_min + get_range (max (r_max - r_min + 1, 0)); -} - -template struct random_number_generator; -template struct random_number_generator; - -/* - * 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) -{ - r_max = max (r_min, r_max); - - int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ - - 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 r_min, sint64 r_max, const object *op, int goodbad) -{ - sint64 omin = r_min; - sint64 range = max (0, r_max - r_min + 1); - int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */ - - /* - * 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 % range) + r_min); - - int luck = op->stats.luck; - - if (rndm (base) < min (10, abs (luck))) - { - /* we have a winner */ - ((luck > 0) ? (luck = 1) : (luck = -1)); - range -= luck; - if (range < 1) - return (omin); /*check again */ - - ((goodbad) ? (r_min += luck) : (range)); - - return (max (omin, min (r_max, (ran % range) + r_min))); - } - - return ran % range + r_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_cmp name) +#if !GCC_VERSION(3,4) +int least_significant_bit (uint32_t x) { - for (materialtype_t *mt = materialt; mt; mt = mt->next) - if (name == mt->name) - return mt; + x &= -x; // this isolates the lowest bit - return 0; -} + int r = 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) - return; - - if (op->materialname != change->materialname) - return; + if (x & 0xaaaaaaaa) r += 1; + if (x & 0xcccccccc) r += 2; + if (x & 0xf0f0f0f0) r += 4; + if (x & 0xff00ff00) r += 8; + if (x & 0xffff0000) r += 16; - 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) - return; - - if (nmt) - lmt = nmt; - else - { - lmt = 0; - - for (mt = materialt; mt; 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; - } - } - - if (lmt) - { - 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'; + return r; } +#endif /******************************************************************************/ /* Checks a player-provided string which will become the msg property of * an object for dangerous input. */ -bool +bool msg_is_safe (const char *msg) { bool safe = true; @@ -446,7 +94,10 @@ signal (SIGABRT, SIG_IGN); signal (SIGSEGV, SIG_DFL); + signal (SIGFPE , SIG_DFL); +#ifdef SIGBUS signal (SIGBUS , SIG_DFL); +#endif signal (SIGILL , SIG_DFL); signal (SIGTRAP, SIG_DFL); @@ -480,7 +131,8 @@ LOG (llevError, "fork abort: %s\n", msg); } -void *salloc_ (int n) throw (std::bad_alloc) +void * +salloc_ (int n) throw (std::bad_alloc) { void *ptr = g_slice_alloc (n); @@ -491,7 +143,8 @@ return ptr; } -void *salloc_ (int n, void *src) throw (std::bad_alloc) +void * +salloc_ (int n, void *src) throw (std::bad_alloc) { void *ptr = salloc_ (n); @@ -509,7 +162,8 @@ #define MAGIC 0xa1b2c35543deadLL -void *g_slice_alloc (unsigned long size) +void * +g_slice_alloc (unsigned long size) { unsigned long *p = (unsigned long *) (g_slice_alloc)(size + sizeof (unsigned long)); *p++ = size ^ MAGIC; @@ -517,12 +171,14 @@ return (void *)p; } -void *g_slice_alloc0 (unsigned long size) +void * +g_slice_alloc0 (unsigned long size) { return memset (g_slice_alloc (size), 0, size); } -void g_slice_free1 (unsigned long size, void *ptr) +void +g_slice_free1 (unsigned long size, void *ptr) { //fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D if (expect_true (ptr)) @@ -546,6 +202,42 @@ /******************************************************************************/ +refcnt_buf::refcnt_buf (size_t size) +{ + static uint32_t empty_buf [2] = { 0, 1 }; // 2 == never deallocated + data = (char *)empty_buf + overhead; + assert (overhead == sizeof (empty_buf)); + inc (); +} + +refcnt_buf::refcnt_buf (void *data, size_t size) +{ + _alloc (size); + memcpy (this->data, data, size); +} + +refcnt_buf::~refcnt_buf () +{ + dec (); +} + +void +refcnt_buf::_dealloc () +{ + sfree (data - overhead, size () + overhead); +} + +refcnt_buf & +refcnt_buf::operator =(const refcnt_buf &src) +{ + dec (); + data = src.data; + inc (); + return *this; +} + +/******************************************************************************/ + int assign (char *dst, const char *src, int maxsize) { @@ -578,7 +270,12 @@ char * vformat (const char *format, va_list ap) { - static dynbuf_text buf; buf.clear (); + static dynbuf_text bufs[8]; + static int bufidx; + + dynbuf_text &buf = bufs [++bufidx & 7]; + + buf.clear (); buf.vprintf (format, ap); return buf; } @@ -594,7 +291,8 @@ return buf; } -tstamp now () +tstamp +now () { struct timeval tv; @@ -669,7 +367,8 @@ 0x2d02ef8dL }; -void thread::start (void *(*start_routine)(void *), void *arg) +void +thread::start (void *(*start_routine)(void *), void *arg) { pthread_attr_t attr;