floors are nicely displayed but i came up with a failure when i try to read the harem dt1. do you have it ??

------------------
---------------------------------------

Diablo II : Cabal Wars

-- Enter the ANATOLIA MUD'S MOD ---

quote:

---

Originally posted by Joel:
floors are nicely displayed but i came up with a failure when i try to read the harem dt1. do you have it ??

---

I found a bug in my code that explains what i do :

* first i plot directly to the screen with the coord of the pixel withou using ClienttoScreen (to get good sized pixel)

Just to be sure, the routine that can display wall in your code is in ds1scene isn't it ,

------------------
---------------------------------------

Diablo II : Cabal Wars

-- Enter the ANATOLIA MUD'S MOD ---

code:

---

   // draw
   for (y=0; y<h+1; y++)
   {
      printf("%3i : ", y);
      fprintf(stderr, "line %3i\n", y);
      base_x = (80 * h) - (80 * y);
      base_y = 40 * y;
      for (x=0; x<w+1; x++)
      {
         xx = base_x + (80 * x);
         yy = base_y + (40 * x);
         
         // floors
         for (l=0; l<x4; l++)
         {
            if (layer[fl_st+l][y][x].p1 > 0)
            {
               draw_block_search1(tmpbmp, xx, yy,
                  layer[fl_st+l][y][x].p2,                // sub-index
                  (layer[fl_st+l][y][x].p3 / 16) +        // main-index
                  ((layer[fl_st+l][y][x].p4 & 0x0F) * 16) // main-index
               );
            }
            else
               printf(" ");
         }
         // walls
         for (l=0; l<x3; l++)
         {
            if (layer[(wa_st+l)*2][y][x].p4 & 0xF0)
               continue;
               
            if ( (layer[(wa_st+l)*2+1][y][x].p1 > 0))
            {
               if (layer[(wa_st+l)*2+1][y][x].p1 == 3)
               {
                  draw_block_search2(tmpbmp, xx, yy,
                     3,                                          // orientation
                     layer[(wa_st+l)*2][y][x].p2,                // sub-index
                     (layer[(wa_st+l)*2][y][x].p3 / 16) +        // main-index
                     ((layer[(wa_st+l)*2][y][x].p4 & 0x0F) * 16) // main-index
                  );
               
                  draw_block_search2(tmpbmp, xx, yy,
                     4,                                          // orientation
                     layer[(wa_st+l)*2][y][x].p2,                // sub-index
                     (layer[(wa_st+l)*2][y][x].p3 / 16) +        // main-index
                     ((layer[(wa_st+l)*2][y][x].p4 & 0x0F) * 16) // main-index
                  );
               }
               else // not upper / left corner
               {
                  draw_block_search2(tmpbmp, xx, yy,
                     layer[(wa_st+l)*2+1][y][x].p1,              // orientation
                     layer[(wa_st+l)*2][y][x].p2,                // sub-index
                     (layer[(wa_st+l)*2][y][x].p3 / 16) +        // main-index
                     ((layer[(wa_st+l)*2][y][x].p4 & 0x0F) * 16) // main-index
                 );
               }
            }
            else
               printf(" ");
         }

---

In summary, I take the prop1 to prop4 from isliveo's editor maps, and make some good indexs, as defined in the dt1 format : orientation / main-index / sub-index, these 3 indexs are passed to functions that search the first tile that have this 3 indexs, and then draw it (don't forget there is a dt1 priority for the search : from left to right in dt1files.txt)

Floors always have an orientation of 0, so I just made a distinct function for them, to not have pass this zero, but you can make an "universal" function. For walls, I check if this is a upper/left corner, and if so draw this tile, WITH another one right after(first is orientation = 3, 2nd is orientation = 4). Else it's a regular tile.

If the high-nibble of a wall is not zero, I don't draw this tile (since it produce blue tiles at tristam and such other errors elsewhere).

In fact, it's pretty simple for me (of course, since *I* made it). But if there are some dark points in there, I can explain.

---------------------------------------

As for the funtions that search and draw the tiles :

code:

---

void draw_block_search1(BITMAP * dst, int x0, int y0, int sub_idx, int main_idx)
{
   BLOCK_S    * block_ptr;
   SUB_TILE_S * tile_ptr;
   UBYTE      * ptr;
   int        b, t, x, y, length, dt1;
   for (dt1=0; dt1<glb_dt1_file; dt1++)
//   for (dt1=glb_dt1_file; dt1>=0; dt1--)
   {
      for (b=0; b<glb_block_number[dt1]; b++)
      {
         block_ptr = glb_block[dt1] + b;
         if ( (block_ptr->sub_index   == sub_idx)  &&
              (block_ptr->orientation == 0)        &&
              (block_ptr->main_index  == main_idx)
            )
         {
            y0 -= block_ptr->y_delta;
            if ((block_ptr->orientation != 0) && (block_ptr->orientation != 15))
               y0 += 80;
            tile_ptr  = block_ptr->tile;
            for(t=0; t<block_ptr->tiles_number; t++)
            {
               length = tile_ptr->data_length;
               ptr    = tile_ptr->data;
               x      = tile_ptr->xpos;
               y      = tile_ptr->ypos;
               if (tile_ptr->format == 0x0001)
                  draw_sub_tile_isometric(dst, x0+x, y0+y, ptr, length);
               else
                  draw_sub_tile_normal(dst, x0+x, y0+y, ptr, length);
               tile_ptr++;
            }
            printf("-");
            return;
         }
      }
   }
   printf("!");
}

// ==========================================================================
void draw_block_search2(BITMAP * dst, int x0, int y0, int orient, int sub_idx, int main_idx)
{
   BLOCK_S    * block_ptr;
   SUB_TILE_S * tile_ptr;
   UBYTE      * ptr;
   int        b, t, x, y, length, dt1;
   for (dt1=0; dt1<glb_dt1_file; dt1++)
//   for (dt1=glb_dt1_file; dt1>=0; dt1--)
   {
      for (b=0; b<glb_block_number[dt1]; b++)
      {
         block_ptr = glb_block[dt1] + b;
         if ( (block_ptr->sub_index   == sub_idx)  &&
              (block_ptr->orientation == orient)   &&
              (block_ptr->main_index  == main_idx)
            )
         {
            y0 -= block_ptr->y_delta;
            if ((block_ptr->orientation != 0) && (block_ptr->orientation != 15))
               y0 += 80;
            tile_ptr  = block_ptr->tile;
            for(t=0; t<block_ptr->tiles_number; t++)
            {
               length = tile_ptr->data_length;
               ptr    = tile_ptr->data;
               x      = tile_ptr->xpos;
               y      = tile_ptr->ypos;
               if (tile_ptr->format == 0x0001)
                  draw_sub_tile_isometric(dst, x0+x, y0+y, ptr, length);
               else
                  draw_sub_tile_normal(dst, x0+x, y0+y, ptr, length);
               tile_ptr++;
            }
//            fprintf(stderr, "%c", b < 223 ? 32 + b : '*');
            switch(orient)
            {
               case  3 : break;
               case  4 : printf("+"); break;
               case 15 : printf("^"); break;
               default : printf("="); break;
            }
            return;
         }
      }
   }
   if (orient == 3)
      printf("#");
   else if (orient == 4)
      printf("@");
   else
      printf("?");
}

---

[...]search1 is for floor and roof, search2 is for the walls. I take into account the "roof height" of the tile before drawing it ("y0 -= block_ptr->y_delta;"), and I draw the walls 80 pixels lower (floor have orientation=0, and roof have orientation=15, so if the tile I want to draw don't have an orientation of one of this 2 value, it's a wall, then I lower it).

code:

---

         // walls
         for (l=0; l<x3; l++)
         {
            if (layer[(wa_st+l)*2][y][x].p4 & 0x80) // binary : 1000-0000
               continue;
               
            if ( (layer[(wa_st+l)*2+1][y][x].p1 > 0))
            {

---

In other words : In a precedent post, I told that if the high nibble of prop 4 of a wall have something, then I don't draw the wall, to avoid the blue square in tristram... but that brings problems in fortress.

In fact, it seems in this high nibble there are only 2 bits that means something. If the higher one is set, THEN I don't draw the tile (0x80 = 10000000 in binary), but if this bit is clear, EVEN if the lowest is set, I draw the tile (0x10 = 00010000 ---> nevermind, draw it). I just check in fortress and tristram, and it seems ok, but I didn't check elsewhere.

This is just a test bitmap I have made with psp, nothing is done yet.

On the left part is a preview of the tile, with all the layers on it. By clicking on "wall 1" you'll see in the big window which tile is selected for the 1 layer of the wall. By clicking fastly on "wall 1" thru "floor 4", you quickly have an idea of what are the elements of the preview. Of course, you'll be able to choose another tile for this element, by just cliking on the big window.

In this image, you see what a user can view if if he have clicked on a floor button (floor can be of 3 types, and walls of 2. This is relative to "orientation"). In this big window, there will be 1 line of tiles for each main-index of this type, the row are for the sub-index. By cliking on a tile, and then clicking on "view same random", you'll bring another window which will show all the tiles of the same combination of orientation / main-index / sub-index (you won't be able to choose one in there, since the game pick 1 randomly, so same for me, I'll always display the 1st).

I'm afraid my explanation are far, very far from perfect, but do you have any suggestions while all this windows are to be code ? I mean it's the moment to ask, because later it'll be harder to change back.

EDIT>>> as for the prog, it needs little less than 20 MB for Harogath, since there are so much tile to load, and all the tiles in this dt1 are in 5 zoom format. But 20 MB are not so much for the PC of nowadays. The prog make a global table of all the blocks it found in the dt1 it needs, in harogath it's just 40 KB (really nothing) for a total of 1063 blocks, and it'll allow me a very good managment for them. When I'll load the ds1, it will search the corresponding index in this table, for each of his cell (not so slow tough).

Ok you don't need to know all this, but I just wanted to show I DO have worked on my editor this week (about 20 hours, or more), even if I don't release something as I have said I would

Next step to code : loading ds1, search the cells / block_table corresponding, display the whole map, keyb / mouse managment, and this windows I have talk about (not really hard, but need to bee very accurate on this part).

quote:

---

Originally posted by Paul Siramy:
I'm afraid my explanation are far, very far from perfect, but do you have any suggestions while all this windows are to be code ? I mean it's the moment to ask, because later it'll be harder to change back.

---

Hmm, I think it looks good, easy to use. I like it

I hope it 'll work, this stuff took me twice time as foreseen

I'm really sorry to have delayed it, i know people want it.

BTW, it could be nice stuff, i try to extract some tile and maps from BGII and IWD, and some of them could be easily transformed to suit the angle of vision of D2 !!

Hmm, nice Irenicus lair, nice Underdark goodies

------------------
---------------------------------------

Diablo II : Cabal Wars

-- Enter the ANATOLIA MUD'S MOD ---

now a question :

wha's the easiest way to turn pcx tile to dt1 ?

i mean for floor it's ok but for walls and floors ??

paul (or someone else)
if you have an idea ?

------------------
---------------------------------------

Diablo II : Cabal Wars

-- Enter the ANATOLIA MUD'S MOD ---

Now, in my dt1make.exe I used 4 pcx, because I didn't want to have hundreds of pcx on my disk, and found that 4 pcx were enough : I have prefer an easier way of tiles-managing for *users* than to *program*. By having all the tiles of the same type on a pcx, you can make copy/past easily. In paint shop pro you can also display a rule, and if you take 160 pixels in x, you see easily all the walls tiles (with 160 pixels in X and 80 pixels in Y, that's really easy in the floor pcx).

In any case, the tiles don't need to be ordered, their index in the dt1 is unsignificant, just the orientation/main index/sub index are important, so you can take the hundreds of pcx in the order you want.

edit>>> corrected what's in bold

For displaying the etile, i used your dt1debug.c file for showing walls and stuffs. But i've tought further and so :

if wall/floors etc .. are coded by main/sub/orientation, the order in the dt1 is unsignificant.

So, should i display every blocks separetly or by such group ?

------------------
---------------------------------------

Diablo II : Cabal Wars

-- Enter the ANATOLIA MUD'S MOD ---

edit>>> I forgot : you can give an optional parameter to the prog now. It's a string of booleans for each layers, to tell if it will be draw or not (check _fortress.bat & _tristram.bat).

You can try this alpha version here if you want. Just edit the ds1edit.ini and change the path to the mpq, if they needs, then launch a .bat . You should see the prog working for a while on making zooms of each block of each dt1 it needs, then go in fullscreen mode, allowing you to scroll around the ds1. ESC to quit.

You can't edit something, just load all the stuff of ds1 and dt1, and then scroll. It's a sort of a mix of my previous ds1scene.exe and ds1test.exe. You can change the resolution of the screen in the ini, as long as the speed of the scroll. This "release" is just for testing purpose (it's bad programmed for the display : it draws again and again the screen, even if you don't touch at the keyboard or the mouse).

* correct display (upper-left corners, no blue tiles in tristram, roofs...)
* zooms ('+' and '-' from the keypad, 1:1, 1:2, 1:4, 1:8 and 1:16)
* layers toggle (F1 to F4 for 4 floors layers, F5 to F8 for wall)
* the tiles on all the layers where is the mouse are grey, that'll help to locate which tile is to edit.

Since I didn't improve the display yet, you may experienced some little problems with the keys. Just hold down the key a little longer it it is the case for you, until the prog read it.

I was afraid that the more tiles I'll display, the slower it'll be (with zoom). In fact it's the opposite a full screen in harogath with a zoom of 1:1 is slower to draw than the entire town at 1:16 (but i have a pentium 166 mmx, so maybe you won't notice the difference).

Zooms don't center on your mouse when changing the zoom, but on the middle of the screen.

* The Home key center the map (usefull if you're lost far outside the map, in the dark

* when the ds1 is opened, it is always at zoom 1:4 and centered

* color depth works now (you can change it in the ini). There is no need to use it right now, since you can only open 1 ds1, so no palette conflicts, but you can test it for your own purpose since this another screen mode, and your screen (and video card) may handle them differently.

* the right click on a tile will bring the really begening of the edit window : there's just some buttons in there, and excepts the OK buttons to exit, they're doing nothing (but at least I have started it, the harder part is done )

* I have made some multiple-tiles-selection tests, and it works well except... that's slow to Hell ! I need to make some internal bitmaps to be useable. So I didn't put that part in this release.

Still, the code of it is done, and it allows to select exactly the part of the tiles you want : you can select / deselect the layers you see, meaning that you can select a floor but no wall of a tile, and then adding a wall but no floor of another far tiles. It's powerfull, but you have to be carefull in what you're selecting. That's the toggling of the layers that tell which layers are to be selected.

I'll make the internal bitmap I need in some times, and then I'll put back this part on the prog, to allow you to test it, but not right now.

the zip is now 250 KB, due to the add of some pcx, and the support of true color mode.

<<< EDIT >>>

* I forgot to say I changed the mouse cursor to the one you use during the game

* In the bottom-left corner there are the cell coordinates of the mouse (like in Isliveo's editor).

* And now even if the *mouse* cursor is outside the map, the *tile* cursor stay inside.

When you right-clik to enter the edit window, the left part of it have the preview tiles now. For now I always draw at the bottom, because most of the tiles we'll editing will be walls, not cliff. Maybe I'll implement a height scroll for this preview window, but later.

While we're in the minor changes, the position of the mouse is save before you enter the edit window, to restore it after you have made your change, this is to stay on the same tile cursor before and after the editing.

This preview window is usefull for looking what are the tiles hiden by the other ones on the same layer. Maybe I'll implement some options for the tiles you have selected, like :
      * delete
      * copy
      * hide (1)
      * change layer (2)

(1) by hiding some walls we'll be able to see behind.

Ho, the zip is "just" 266 kB now, I mistakly put the "test.pcx" in the precedent zip (nothing important, but big).

In this update, you can see the tabs in the edit window, and they change accordingly to the wall/floor button you click, but there's nothing in the tabs yet. The prog check all the dt1 the ds1 ask to load, and only show the tabs where there are tiles in it. So in most of the ds1 you won't see the "lower walls" tab, nor the "animated floors". Try Harrogat for having most of them.

See you... next week.

<<< EDIT >>>
I couldn't resist, I have to code before sleeping so ... there's a FPS in the upper/right corner now (if you don't move, it goes to zero, just normal since it display the frames it *have to* display the last second, and if you don't move just the mouse need to be redraw), and some various tinny things.

Now, analysing it back with isilveo's editor I' mwondering if ... if the prop1 of a wall layer (the map 0 in this case) don't indicate the drawing priority ? Usually in the ds1 we see the prop1 is equal to 129, but in the Fortress we see 129, 137, 145...

I'm almost sure this prop1 (wich I never used before in my ds1scene.exe, since I didn't understood what was its use) indicate the drawing priority of a cell !