[ViewVC] Diff of: cvs/deliantra/server/random

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.37 by root, Fri May 2 21:01:53 2008 UTC vs.
Revision 1.40 by root, Thu May 8 13:47:19 2008 UTC

 /*  a macro to get a strongly centered random distribution,
     from 0 to x, centered at x/2 */
 static int
 bc_random (int x)
 {
-  return (rndm (x) + rndm (x) + rndm (x)) / 3;
+  return (rmg_rndm (x) + rmg_rndm (x) + rmg_rndm (x)) / 3;
+}
+static object *
+gen_key (const shstr &keycode)
+{
+  /* get a key and set its keycode */
+  object *key = archetype::get (shstr_key2);
+  key->slaying = keycode;
+  key->stats.food = 100;
+  key->speed_left = -1.f;
+  key->flag [FLAG_IS_USED_UP] = true;
+  key->set_speed (1.f / 300.f);
+  return key;
+}
+/* places keys in the map, preferably in something alive.
+        keycode is the key's code,
+        door_flag is either PASS_DOORS or NO_PASS_DOORS.
+          NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
+        if n_keys is 1, it will place 1 key.  if n_keys >1, it will place 2-4 keys:
+        it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
+        The idea is that you call keyplace on x,y where a door is, and it'll make
+        sure a key is placed on both sides of the door.
+*/
+static int
+keyplace (maptile *map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params *RP)
+{
+  int i, j;
+  int kx = 0, ky = 0;
+  object *the_keymaster;        /* the monster that gets the key. */
+  object *the_key = gen_key (keycode);
+  if (door_flag == PASS_DOORS)
+    {
+      int tries = 0;
+      the_keymaster = 0;
+      while (tries < 15 && !the_keymaster)
+        {
+          i = rmg_rndm (RP->Xsize - 2) + 1;
+          j = rmg_rndm (RP->Ysize - 2) + 1;
+          tries++;
+          the_keymaster = find_closest_monster (map, i, j, RP);
+        }
+      /* if we don't find a good keymaster, drop the key on the ground. */
+      if (!the_keymaster)
+        {
+          int freeindex;
+          freeindex = -1;
+          for (tries = 0; tries < 15 && freeindex == -1; tries++)
+            {
+              kx = rmg_rndm (RP->Xsize - 2) + 1;
+              ky = rmg_rndm (RP->Ysize - 2) + 1;
+              freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
+            }
+          // can freeindex ever be < 0?
+          if (freeindex >= 0)
+            {
+              kx += freearr_x [freeindex];
+              ky += freearr_y [freeindex];
+            }
+        }
+    }
+  else
+    {                           /* NO_PASS_DOORS --we have to work harder. */
+      /* don't try to keyplace if we're sitting on a blocked square and
+         NO_PASS_DOORS is set. */
+      if (n_keys == 1)
+        {
+          if (wall_blocked (map, x, y))
+            {
+              the_key->destroy ();
+              return 0;
+            }
+          the_keymaster = find_monster_in_room (map, x, y, RP);
+          if (!the_keymaster)    /* if fail, find a spot to drop the key. */
+            find_spot_in_room (map, x, y, &kx, &ky, RP);
+        }
+      else
+        {
+          int sum = 0;          /* count how many keys we actually place */
+          /* I'm lazy, so just try to place in all 4 directions. */
+          sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
+          sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
+          sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
+          sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
+          if (sum < 2)          /* we might have made a disconnected map-place more keys. */
+            {                   /* diagonally this time. */
+              keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
+              keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
+              keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
+              keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
+            }
+          the_key->destroy ();
+          return 1;
+        }
+    }
+  if (the_keymaster)
+    the_keymaster->head_ ()->insert (the_key);
+  else
+    {
+      the_key->x = kx;
+      the_key->y = ky;
+      insert_ob_in_map (the_key, map, NULL, 0);
+    }
+  return 1;
 }
 /* returns true if square x,y has P_NO_PASS set, which is true for walls
  * and doors but not monsters.
  * This function is not map tile aware.
   if (treasure_style)
     if (!strcmp (treasure_style, "none"))
       return;
   if (treasureoptions <= 0)
-    treasureoptions = rndm (2 * LAST_OPTION);
+    treasureoptions = rmg_rndm (2 * LAST_OPTION);
   /* filter out the mutually exclusive options */
   if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
     {
-      if (rndm (2))
+      if (rmg_rndm (2))
         treasureoptions -= 1;
       else
         treasureoptions -= 2;
     }
               i = j = -1;
               tries = 0;
               while (i == -1 && tries < 100)
                 {
-                  i = rndm (RP->Xsize - 2) + 1;
+                  i = rmg_rndm (RP->Xsize - 2) + 1;
-                  j = rndm (RP->Ysize - 2) + 1;
+                  j = rmg_rndm (RP->Ysize - 2) + 1;
                   find_enclosed_spot (map, &i, &j, RP);
                   if (wall_blocked (map, i, j))
                     i = -1;
     {                           /* DIFFUSE treasure layout */
       int ti, i, j;
       for (ti = 0; ti < num_treasures; ti++)
         {
-          i = rndm (RP->Xsize - 2) + 1;
+          i = rmg_rndm (RP->Xsize - 2) + 1;
-          j = rndm (RP->Ysize - 2) + 1;
+          j = rmg_rndm (RP->Ysize - 2) + 1;
           place_chest (treasureoptions, i, j, map, style_map, 1, RP);
         }
     }
 }
         determined (may be null, or may be a treasure list from lib/treasures,
         if the global variable "treasurestyle" is set to that treasure list's name */
 object *
 place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP)
 {
-  object *the_chest;
-  int i, xl, yl;
-  the_chest = get_archetype ("chest");  /* was "chest_2" */
+  object *the_chest = archetype::get (shstr_chest);  /* was "chest_2" */
   /* first, find a place to put the chest. */
-  i = find_first_free_spot (the_chest, map, x, y);
+  int i = find_first_free_spot (the_chest, map, x, y); // this call uses the main rng
   if (i == -1)
     {
       the_chest->destroy ();
       return NULL;
     }
-  xl = x + freearr_x[i];
+  int xl = x + freearr_x[i];
-  yl = y + freearr_y[i];
+  int yl = y + freearr_y[i];
   /* if the placement is blocked, return a fail. */
   if (wall_blocked (map, xl, yl))
     return 0;
   treasurelist *tlist = find_treasurelist (RP->treasurestyle);
   if (tlist != NULL)
     for (ti = 0; ti < n_treasures; ti++)
       {                         /* use the treasure list */
-        object *new_treasure = style_map->pick_random_object ();
+        object *new_treasure = style_map->pick_random_object (rmg_rndm);
         insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);
       }
   else
     {                           /* use the style map */
     {
       maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
       if (trap_map)
         {
-          object *the_trap = trap_map->pick_random_object ();
+          object *the_trap = trap_map->pick_random_object (rmg_rndm);
           the_trap->stats.Cha = 10 + RP->difficulty;
           the_trap->level = bc_random ((3 * RP->difficulty) / 2);
           if (the_trap)
   /* set the chest lock code, and call the keyplacer routine with
      the lockcode.  It's not worth bothering to lock the chest if
      there's only 1 treasure.... */
   if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
     {
-      char keybuf[1024];
+      the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
-      sprintf (keybuf, "%d", rndm (1000000000));
-      the_chest->slaying = keybuf;
-      keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);
+      keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
     }
   /* actually place the chest. */
   the_chest->x = xl;
   the_chest->y = yl;
           }
     }
   return NULL;
 }
-/* places keys in the map, preferably in something alive.
-        keycode is the key's code,
-        door_flag is either PASS_DOORS or NO_PASS_DOORS.
-          NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
-        if n_keys is 1, it will place 1 key.  if n_keys >1, it will place 2-4 keys:
-        it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
-        The idea is that you call keyplace on x,y where a door is, and it'll make
-        sure a key is placed on both sides of the door.
-*/
-int
-keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP)
-{
-  int i, j;
-  int kx = 0, ky = 0;
-  object *the_keymaster;        /* the monster that gets the key. */
-  object *the_key;
-  /* get a key and set its keycode */
-  the_key = get_archetype ("key2");
-  the_key->slaying = keycode;
-  if (door_flag == PASS_DOORS)
-    {
-      int tries = 0;
-      the_keymaster = 0;
-      while (tries < 15 && !the_keymaster)
-        {
-          i = rndm (RP->Xsize - 2) + 1;
-          j = rndm (RP->Ysize - 2) + 1;
-          tries++;
-          the_keymaster = find_closest_monster (map, i, j, RP);
-        }
-      /* if we don't find a good keymaster, drop the key on the ground. */
-      if (!the_keymaster)
-        {
-          int freeindex;
-          freeindex = -1;
-          for (tries = 0; tries < 15 && freeindex == -1; tries++)
-            {
-              kx = rndm (RP->Xsize - 2) + 1;
-              ky = rndm (RP->Ysize - 2) + 1;
-              freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
-            }
-          // can freeindex ever be < 0?
-          if (freeindex >= 0)
-            {
-              kx += freearr_x [freeindex];
-              ky += freearr_y [freeindex];
-            }
-        }
-    }
-  else
-    {                           /* NO_PASS_DOORS --we have to work harder. */
-      /* don't try to keyplace if we're sitting on a blocked square and
-         NO_PASS_DOORS is set. */
-      if (n_keys == 1)
-        {
-          if (wall_blocked (map, x, y))
-            return 0;
-          the_keymaster = find_monster_in_room (map, x, y, RP);
-          if (!the_keymaster)    /* if fail, find a spot to drop the key. */
-            find_spot_in_room (map, x, y, &kx, &ky, RP);
-        }
-      else
-        {
-          int sum = 0;          /* count how many keys we actually place */
-          /* I'm lazy, so just try to place in all 4 directions. */
-          sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
-          sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
-          sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
-          sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
-          if (sum < 2)          /* we might have made a disconnected map-place more keys. */
-            {                   /* diagonally this time. */
-              keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
-              keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
-              keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
-              keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
-            }
-          return 1;
-        }
-    }
-  if (!the_keymaster)
-    {
-      the_key->x = kx;
-      the_key->y = ky;
-      insert_ob_in_map (the_key, map, NULL, 0);
-      return 1;
-    }
-  insert_ob_in_ob (the_key, the_keymaster->head_ ());
-  return 1;
-}
 /* both find_monster_in_room routines need to have access to this. */
 object *theMonsterToFind;
 /* a recursive routine which will return a monster, eventually,if there is one.
           return theMonsterToFind;
         }
     }
   /* now search all the 8 squares around recursively for a monster,in random order */
-  for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
+  for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
     {
       theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
       if (theMonsterToFind != NULL)
         return theMonsterToFind;
     }
   room_free_spots_x[number_of_free_spots_in_room] = x;
   room_free_spots_y[number_of_free_spots_in_room] = y;
   number_of_free_spots_in_room++;
   /* now search all the 8 squares around recursively for free spots,in random order */
-  for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
+  for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
     find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
 }
 /* find a random non-blocked spot in this room to drop a key. */
   /* setup num_free_spots and room_free_spots */
   find_spot_in_room_recursive (layout2, x, y, RP);
   if (number_of_free_spots_in_room > 0)
     {
-      i = rndm (number_of_free_spots_in_room);
+      i = rmg_rndm (number_of_free_spots_in_room);
       *kx = room_free_spots_x[i];
       *ky = room_free_spots_y[i];
     }
   /* deallocate the temp. layout */
           *cy = ly;
           return;
         }
     }
   /* give up and return the closest free spot. */
-  i = find_free_spot (archetype::find ("chest"), map, x, y, 1, SIZEOFFREE1 + 1);
+  i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
   if (i != -1)
     {
       *cx = x + freearr_x[i];
       *cy = y + freearr_y[i];
   else
     {
       layout[x][y] = 1;
       /* now search all the 8 squares around recursively for free spots,in random order */
-      for (i = rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
+      for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
         find_doors_in_room_recursive (layout, map,
                                       x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
                                       doorlist, ndoors, RP);
     }
 }
   if (opts & DOORED)
     {
       for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
         {
           object *new_door = get_archetype ("locked_door1");
-          char keybuf[1024];
           door = doorlist[i];
           new_door->face = door->face;
           new_door->x = door->x;
           new_door->y = door->y;
           door->remove ();
           door->destroy ();
           doorlist[i] = new_door;
           insert_ob_in_map (new_door, map, NULL, 0);
-          sprintf (keybuf, "%d", rndm (1000000000));
+          new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
-          new_door->slaying = keybuf;
-          keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP);
+          keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
         }
     }
   /* change the faces of the doors and surrounding walls to hide them. */
   if (opts & HIDDEN)

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.37 by root, Fri May 2 21:01:53 2008 UTC vs. Revision 1.40 by root, Thu May 8 13:47:19 2008 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.37 by root, Fri May 2 21:01:53 2008 UTC vs.
Revision 1.40 by root, Thu May 8 13:47:19 2008 UTC