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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.48 by root, Sun Nov 29 17:41:07 2009 UTC vs.
Revision 1.57 by root, Fri Jul 2 15:03:57 2010 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
- * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 2001 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.
 #define NO_PASS_DOORS 0
 #define PASS_DOORS 1
 static object *find_closest_monster (maptile *map, int x, int y, random_map_params *RP);
 static object *find_monster_in_room (maptile *map, int x, int y, random_map_params *RP);
-static void find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP);
+static void find_spot_in_room_recursive (char **maze, int x, int y, random_map_params *RP);
 static void find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP);
 static object *place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP);
 static object **find_doors_in_room (maptile *map, int x, int y, random_map_params *RP);
 static void lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP);
 static void find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP);
-static object **surround_by_doors (maptile *map, char **layout, int x, int y, int opts);
+static object **surround_by_doors (maptile *map, char **maze, int x, int y, int opts);
 /*  a macro to get a strongly centered random distribution,
     from 0 to x, centered at x/2 */
 static int
 bc_random (int x)
           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);
+              freeindex = rmg_find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
             }
           // can freeindex ever be < 0?
           if (freeindex >= 0)
             {
   return GET_MAP_MOVE_BLOCK (m, x, y) & MOVE_WALK;
 }
 /* place treasures in the map, given the
 map,         (required)
-layout,      (required)
+maze,      (required)
 treasure style    (may be empty or NULL, or "none" to cause no treasure.)
 treasureoptions   (may be 0 for random choices or positive)
 */
 void
-place_treasure (maptile *map, char **layout, char *treasure_style, int treasureoptions, random_map_params *RP)
+place_treasure (maptile *map, char **maze, const char *treasure_style, int treasureoptions, random_map_params *RP)
 {
-  char styledirname[1024];
-  char stylefilepath[1024];
-  maptile *style_map = 0;
   int num_treasures;
   /* bail out if treasure isn't wanted. */
   if (treasure_style)
     if (!strcmp (treasure_style, "none"))
   if (num_treasures <= 0)
     return;
   /* get the style map */
-  sprintf (styledirname, "%s", "/styles/treasurestyles");
+  maptile *style_map = find_style ("/styles/treasurestyles", treasure_style, RP->difficulty);
-  sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
-  style_map = find_style (styledirname, treasure_style, -1);
   if (!style_map)
     {
-      LOG (llevError, "unable to load style map %s %s.\n", styledirname, treasure_style);
+      LOG (llevError, "unable to load style map %s %s.\n", "/styles/treasurestyles", treasure_style);
       return;
     }
   /* all the treasure at one spot in the map. */
   if (treasureoptions & CONCENTRATED)
               /* search the onion for C's or '>', and put treasure there. */
               for (i = 0; i < RP->Xsize; i++)
                 {
                   for (j = 0; j < RP->Ysize; j++)
                     {
-                      if (layout[i][j] == 'C' || layout[i][j] == '>')
+                      if (maze[i][j] == 'C' || maze[i][j] == '>')
                         {
                           int tdiv = RP->symmetry_used;
                           object *chest;
                           if (tdiv == 3)
               i = chest->x;
               j = chest->y;
               if (treasureoptions & (DOORED | HIDDEN))
                 {
-                  doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
+                  doorlist = surround_by_doors (map, maze, i, j, treasureoptions);
                   lock_and_hide_doors (doorlist, map, treasureoptions, RP);
                   free (doorlist);
                 }
             }
         }
     }
   else
-    {                           /* DIFFUSE treasure layout */
+    {                           /* DIFFUSE treasure maze */
       int ti, i, j;
       for (ti = 0; ti < num_treasures; ti++)
         {
           i = rmg_rndm (RP->Xsize - 2) + 1;
   }
   /* stick a trap in the chest if required  */
   if (treasureoptions & TRAPPED)
     {
-      maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
+      maptile *trap_map = find_style ("/styles/trapstyles", "traps", RP->difficulty);
       if (trap_map)
         {
           object *the_trap = trap_map->pick_random_object (rmg_rndm);
         /* don't bother searching this square unless the map says life exists. */
         if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
           {
             object *the_monster = GET_MAP_OB (map, lx, ly);
-            for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_MONSTER)); the_monster = the_monster->above);
+            for (; the_monster != NULL && (!the_monster->flag [FLAG_MONSTER]); the_monster = the_monster->above);
-            if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))
+            if (the_monster && the_monster->flag [FLAG_MONSTER])
               return the_monster;
           }
     }
   return NULL;
 }
 /* both find_monster_in_room routines need to have access to this. */
 static object *theMonsterToFind;
 /* a recursive routine which will return a monster, eventually,if there is one.
-   it does a check-off on the layout, converting 0's to 1's */
+   it does a check-off on the maze, converting 0's to 1's */
 static object *
-find_monster_in_room_recursive (char **layout, maptile *map, int x, int y, random_map_params *RP)
+find_monster_in_room_recursive (char **maze, maptile *map, int x, int y, random_map_params *RP)
 {
   int i, j;
   /* if we've found a monster already, leave */
   if (theMonsterToFind != NULL)
   /* bounds check x and y */
   if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
     return theMonsterToFind;
   /* if the square is blocked or searched already, leave */
-  if (layout[x][y] != 0)
+  if (maze[x][y] != 0)
     return theMonsterToFind;    /* might be NULL, that's fine. */
   /* check the current square for a monster.  If there is one,
      set theMonsterToFind and return it. */
-  layout[x][y] = 1;
+  maze[x][y] = 1;
   if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
     {
       object *the_monster = GET_MAP_OB (map, x, y);
       /* check off this point */
-      for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above);
+      for (; the_monster != NULL && (!the_monster->flag [FLAG_ALIVE]); the_monster = the_monster->above);
-      if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))
+      if (the_monster && the_monster->flag [FLAG_ALIVE])
         {
           theMonsterToFind = the_monster;
           return theMonsterToFind;
         }
     }
   /* now search all the 8 squares around recursively for a monster,in random order */
   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);
+      theMonsterToFind = find_monster_in_room_recursive (maze, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
       if (theMonsterToFind != NULL)
         return theMonsterToFind;
     }
   return theMonsterToFind;
 /* sets up some data structures:  the _recursive form does the
    real work.  */
 static object *
 find_monster_in_room (maptile *map, int x, int y, random_map_params *RP)
 {
-  Layout layout2 (RP);
+  layout layout2 (map->width, map->height);
-  layout2->clear ();
+  // find walls
-  /* allocate and copy the layout, converting C to 0. */
-  for (int i = 0; i < layout2->w; i++)
+  for (int i = 0; i < layout2.w; i++)
-    for (int j = 0; j < layout2->h; j++)
+    for (int j = 0; j < layout2.h; j++)
-      if (wall_blocked (map, i, j))
+      layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
-        layout2[i][j] = '#';
   theMonsterToFind = 0;
   theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
-  layout2.free ();
   return theMonsterToFind;
 }
 /* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
 /* the workhorse routine, which finds the free spots in a room:
 a datastructure of free points is set up, and a position chosen from
 that datastructure. */
 static void
-find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP)
+find_spot_in_room_recursive (char **maze, int x, int y, random_map_params *RP)
 {
   int i, j;
   /* bounds check x and y */
   if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
     return;
   /* if the square is blocked or searched already, leave */
-  if (layout[x][y] != 0)
+  if (maze[x][y] != 0)
     return;
   /* set the current square as checked, and add it to the list.
      set theMonsterToFind and return it. */
   /* check off this point */
-  layout[x][y] = 1;
+  maze[x][y] = 1;
   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 = 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_spot_in_room_recursive (maze, 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. */
 static void
   number_of_free_spots_in_room = 0;
   room_free_spots_x = (int *) calloc (sizeof (int), RP->Xsize * RP->Ysize);
   room_free_spots_y = (int *) calloc (sizeof (int), RP->Xsize * RP->Ysize);
   layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
-  /* allocate and copy the layout, converting C to 0. */
+  /* allocate and copy the maze, converting C to 0. */
   for (i = 0; i < RP->Xsize; i++)
     {
       layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
       for (j = 0; j < RP->Ysize; j++)
         if (wall_blocked (map, i, j))
       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 */
+  /* deallocate the temp. maze */
   for (i = 0; i < RP->Xsize; i++)
     free (layout2[i]);
   free (layout2);
   free (room_free_spots_x);
     {
       int lx, ly, sindex;
       lx = x + freearr_x[i];
       ly = y + freearr_y[i];
-      sindex = surround_flag3 (map, lx, ly, RP);
+      sindex = surround_flag3 (map, lx, ly);
       /* if it's blocked on 3 sides, it's enclosed */
       if (sindex == 7 || sindex == 11 || sindex == 13 || sindex == 14)
         {
           *cx = lx;
           *cy = ly;
     {
       int lx, ly, sindex;
       lx = x + freearr_x[i];
       ly = y + freearr_y[i];
-      sindex = surround_flag3 (map, lx, ly, RP);
+      sindex = surround_flag3 (map, lx, ly);
       /* if it's blocked on 3 sides, it's enclosed */
       if (sindex == 3 || sindex == 5 || sindex == 9 || sindex == 6 || sindex == 10 || sindex == 12)
         {
           *cx = lx;
           *cy = ly;
     {
       int lx, ly, sindex;
       lx = x + freearr_x[i];
       ly = y + freearr_y[i];
-      sindex = surround_flag3 (map, lx, ly, RP);
+      sindex = surround_flag3 (map, lx, ly);
       /* if it's blocked on 3 sides, it's enclosed */
       if (sindex)
         {
           *cx = lx;
           *cy = ly;
           return;
         }
     }
   /* give up and return the closest free spot. */
-  i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
+  i = rmg_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];
 /*  surrounds the point x,y by doors, so as to enclose something, like
          a chest.  It only goes as far as the 8 squares surrounding, and
          it'll remove any monsters it finds.*/
 static object **
-surround_by_doors (maptile *map, char **layout, int x, int y, int opts)
+surround_by_doors (maptile *map, char **maze, int x, int y, int opts)
 {
   int i;
   const char *doors[2];
   object **doorlist;
   int ndoors_made = 0;
   /* place doors in all the 8 adjacent unblocked squares. */
   for (i = 1; i < 9; i++)
     {
       int x1 = x + freearr_x[i], y1 = y + freearr_y[i];
-      if (!wall_blocked (map, x1, y1) && layout[x1][y1] == '>')
+      if (!wall_blocked (map, x1, y1) && maze[x1][y1] == '>')
         {                       /* place a door */
           remove_monsters (x1, y1, map);
           object *new_door = get_archetype (freearr_x[i] == 0 ? doors[1] : doors[0]);
           map->insert (new_door, x1, y1);
   return NULL;
 }
 /* the workhorse routine, which finds the doors in a room */
 static void
-find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
+find_doors_in_room_recursive (char **maze, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
 {
   int i, j;
   object *door;
   /* bounds check x and y */
   if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
     return;
   /* if the square is blocked or searched already, leave */
-  if (layout[x][y] == 1)
+  if (maze[x][y] == 1)
     return;
   /* check off this point */
-  if (layout[x][y] == '#')
+  if (maze[x][y] == '#')
     {                           /* there could be a door here */
-      layout[x][y] = 1;
+      maze[x][y] = 1;
       door = door_in_square (map, x, y);
       if (door)
         {
           doorlist[*ndoors] = door;
           *ndoors = *ndoors + 1;
         }
     }
   else
     {
-      layout[x][y] = 1;
+      maze[x][y] = 1;
       /* now search all the 8 squares around recursively for free spots,in random order */
       for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
-        find_doors_in_room_recursive (layout, map,
+        find_doors_in_room_recursive (maze, map,
                                       x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
                                       doorlist, ndoors, RP);
     }
 }
   int i, j;
   int ndoors = 0;
   object **doorlist = (object **)calloc (sizeof (int), 1024);
-  LayoutData layout2 (RP->Xsize, RP->Ysize);
+  layout layout2 (RP->Xsize, RP->Ysize);
   layout2.clear ();
-  /* allocate and copy the layout, converting C to 0. */
+  /* allocate and copy the maze, converting C to 0. */
   for (i = 0; i < RP->Xsize; i++)
     for (j = 0; j < RP->Ysize; j++)
       layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
   /* setup num_free_spots and room_free_spots */

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.48 by root, Sun Nov 29 17:41:07 2009 UTC vs. Revision 1.57 by root, Fri Jul 2 15:03:57 2010 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.48 by root, Sun Nov 29 17:41:07 2009 UTC vs.
Revision 1.57 by root, Fri Jul 2 15:03:57 2010 UTC