[ViewVC] Diff of: cvs/deliantra/server/common/compat.C

Comparing deliantra/server/common/compat.C (file contents):
Revision 1.2 by root, Fri Nov 6 13:03:34 2009 UTC vs.
Revision 1.19 by root, Sat Nov 17 23:40:00 2018 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
+ * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
- * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
- * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
- * Copyright (©) 1992,2007 Frank Tore Johansen
+ * Copyright (©) 1992 Frank Tore Johansen
  *
  * 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
  * <http://www.gnu.org/licenses/>.
  *
  * The authors can be reached via e-mail to <support@deliantra.net>
  */
 /*
  * compatibility functions for older (GPL) source code parts
 #include <global.h>
 #include "define.h"
 #include "path.h"
 /* buf_overflow() - we don't want to exceed the buffer size of
  * buf1 by adding on buf2! Returns true if overflow will occur.
  */
 int
 buf_overflow (const char *buf1, const char *buf2, int bufsize)
 {
   if ((len1 + len2) >= bufsize)
     return 1;
   return 0;
-}
-/////////////////////////////////////////////////////////////////////////////
-static const char *const fatalmsgs[80] = {
-  "Failed to allocate memory",
-  "Failed repeatedly to load maps",
-  "Hashtable for archetypes is too small",
-  "Too many errors"
-};
-/*
- * fatal() is meant to be called whenever a fatal signal is intercepted.
- * It will call the emergency_save and the clean_tmp_files functions.
- */
-void
-fatal (int err)
-{
-  LOG (llevError, "Fatal: %s\n", fatalmsgs [err]);
-  cleanup (fatalmsgs[err], 1);
 }
 /////////////////////////////////////////////////////////////////////////////
 /*
  * 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)
+random_roll (int r_min, int r_max, const object *op, bool prefer_high)
 {
-  r_max = max (r_min, r_max);
+  if (r_min > r_max)
+    swap (r_min, r_max);
+  int range = r_max - r_min + 1;
+  int num = rndm (r_min, r_max);
+  if (op->stats.luck)
+    {
-  int base = r_max - r_min > 1 ? 20 : 50;     /* d2 and d3 are corner cases */
+      int base = range > 2 ? 20 : 50;     /* d2 and d3 are corner cases */
-  if (op->type == PLAYER)
-    {
-      int luck = op->stats.luck;
-      if (rndm (base) < min (10, abs (luck)))
+      if (rndm (base) < min (10, abs (op->stats.luck)))
-        {
-          //TODO: take luck into account
-        }
+        {
-    }
+          // we have a winner, increase/decrease number by one accordingly
+          int adjust = sign (op->stats.luck);
-  return rndm (r_min, r_max);
+          if (!prefer_high)
+            adjust = -adjust;
+          num = clamp (num + adjust, r_min, r_max);
+        }
+    }
+  return num;
 }
 /*
  * 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)
+random_roll64 (sint64 r_min, sint64 r_max, const object *op, bool prefer_high)
 {
-  sint64 omin = r_min;
+  if (r_min > r_max)
+    swap (r_min, r_max);
-  sint64 range = max (0, r_max - r_min + 1);
+  sint64 range = 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
+   * Make a call to get two 32 bit unsigned random numbers, and just do
    * a little bitshifting.
    */
-  sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
+  sint64 num = rndm.next () ^ (sint64 (rndm.next ()) << 31);
-  if (op->type != PLAYER)
+  num = num % range + r_min;
-    return ((ran % range) + r_min);
-  int luck = op->stats.luck;
+  if (op->stats.luck)
+    {
+      int base = range > 2 ? 20 : 50;     /* d2 and d3 are corner cases */
-  if (rndm (base) < min (10, abs (luck)))
+      if (rndm (base) < min (10, abs (op->stats.luck)))
+        {
+          // we have a winner, increase/decrease number by one accordingly
+          int adjust = sign (op->stats.luck);
+          if (!prefer_high)
+            adjust = -adjust;
+          num = clamp (num + adjust, r_min, r_max);
+        }
-    {
+    }
-      /* 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 num;
-      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)
+die_roll (int num, int size, const object *op, bool prefer_high)
 {
-  int min, luck, total, i, gotlucky;
+  int min_roll, luck, total, i, gotlucky;
   int diff = size;
-  min = 1;
+  min_roll = 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);
+      LOG (llevError | logBacktrace, "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)
+      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));
+          ((prefer_high) ? (min_roll += luck) : (diff));
-          total += MAX (1, MIN (size, rndm (diff) + min));
+          total += max (1, min (size, rndm (diff) + min_roll));
         }
       else
         total += rndm (size) + 1;
     }
   path = path_combine (src, dst);
   path_normalize (path);
   return (path);
 }
-/**
- * open_and_uncompress() first searches for the original filename. If it exist,
- * then it opens it and returns the file-pointer.
- */
-FILE *
-open_and_uncompress (const char *name, int flag, int *compressed)
-{
-  *compressed = 0;
-  return fopen (name, "r");
-}
-/*
- * See open_and_uncompress().
- */
-void
-close_and_delete (FILE * fp, int compressed)
-{
-  fclose (fp);
-}
-/*
- * 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"))
+  if (*buf && buf [strlen (buf) - 1] == '\n')
-    {
-      return;
-    }
-  if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
-    buf[strlen (buf) - EOL_SIZE] = '\0';
+    buf [strlen (buf) - 1] = '\0';
 }
 /**
  * Replace in string src all occurrences of key by replacement. The resulting
  * string is put into result; at most resultsize characters (including the

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/common/compat.C (file contents): Revision 1.2 by root, Fri Nov 6 13:03:34 2009 UTC vs. Revision 1.19 by root, Sat Nov 17 23:40:00 2018 UTC

Diff Legend

Comparing deliantra/server/common/compat.C (file contents):
Revision 1.2 by root, Fri Nov 6 13:03:34 2009 UTC vs.
Revision 1.19 by root, Sat Nov 17 23:40:00 2018 UTC