d2dmap.d

   1 /* DooM2D: Midnight on the Firing Line
   2  * coded by Ketmar // Invisible Vector <ketmar@ketmar.no-ip.org>
   3  * Understanding is not required. Only obedience.
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 module d2dmap is aliced;
  19 private:
  20
  21 import arsd.color;
  22 import iv.vfs;
  23 import iv.cmdcon;
  24
  25 import glutils;
  26
  27 import d2dimage;
  28
  29 import iv.vfs;
  30 import iv.vfs.koi8;
  31
  32
  33 // ////////////////////////////////////////////////////////////////////////// //
  34 public enum TileSize = 8;
  35
  36
  37 // ////////////////////////////////////////////////////////////////////////// //
  38 Color getPixel (TrueColorImage img, int x, int y) {
  39   if (x >= 0 && y >= 0 && x < img.width && y < img.height) {
  40     return img.imageData.colors.ptr[y*img.width+x];
  41   } else {
  42     return Color(0, 0, 0, 0);
  43   }
  44 }
  45
  46
  47 void putPixel (TrueColorImage img, int x, int y, Color clr) {
  48   if (x >= 0 && y >= 0 && x < img.width && y < img.height && clr.a != 0) {
  49     img.imageData.colors.ptr[y*img.width+x] = clr;
  50   }
  51 }
  52
  53
  54 void fixPixelA (TrueColorImage img, int x, int y, ubyte a) {
  55   if (x >= 0 && y >= 0 && x < img.width && y < img.height) {
  56     img.imageData.colors.ptr[y*img.width+x].a = a;
  57   }
  58 }
  59
  60
  61 void fixPixelTileA (TrueColorImage img, int x, int y, ubyte a) {
  62   foreach (int dy; 0..TileSize) {
  63     foreach (int dx; 0..TileSize) {
  64       fixPixelA(img, x+dx, y+dy, a);
  65     }
  66   }
  67 }
  68
  69
  70 void putPixelTile (TrueColorImage img, int x, int y, Color clr) {
  71   foreach (int dy; 0..TileSize) {
  72     foreach (int dx; 0..TileSize) {
  73       putPixel(img, x+dx, y+dy, clr);
  74     }
  75   }
  76 }
  77
  78
  79 void putTile (TrueColorImage img, int x, int y, D2DImage wt) {
  80   if (wt is null) return;
  81   x -= wt.sx;
  82   y -= wt.sy;
  83   foreach (int dy; 0..wt.height) {
  84     foreach (int dx; 0..wt.width) {
  85       img.putPixel(x+dx, y, wt.getPixel(dx, dy));
  86     }
  87     ++y;
  88   }
  89 }
  90
  91
  92 // temp
  93 static ubyte clampByte (ubyte b, int delta) {
  94   delta += b;
  95   return cast(ubyte)(delta < 0 ? 0 : delta > 255 ? 255 : delta);
  96 }
  97
  98
  99 // ////////////////////////////////////////////////////////////////////////// //
 100 public final class LevelMap {
 101 private:
 102   enum MapVersion = 2; // óÁÍÁÑ ÐÏÓÌÅÄÎÑÑ ×ÅÒÓÉÑ ËÁÒÔÙ
 103   public enum MapSize = 100;
 104
 105 public:
 106   // tile type
 107   enum : ubyte {
 108     TILE_EMPTY = 0,
 109     TILE_WALL = 1,
 110     TILE_DOORC = 2, // closed door
 111     TILE_DOORO = 3, // opened door
 112     TILE_STEP = 4,
 113     TILE_WATER = 5,
 114     TILE_ACID1 = 6,
 115     TILE_ACID2 = 7,
 116     TILE_MBLOCK = 8, // just blocks monsters
 117     TILE_LIFTU = 9,
 118     TILE_LIFTD = 10,
 119     //
 120     TILE_ACTTRAP = 255,
 121   }
 122
 123   enum : short {
 124     MB_COMMENT = -1,
 125     MB_END = 0,
 126     MB_WALLNAMES,
 127     MB_BACK,
 128     MB_WTYPE,
 129     MB_FRONT,
 130     MB_THING,
 131     MB_SWITCH,
 132     MB_MUSIC, // usually 8 bytes
 133     MB_SKY, // ushort: [1..3]
 134     MB_SWITCH2,
 135   }
 136
 137   enum {
 138     SW_PL_PRESS = 1<<0,
 139     SW_MN_PRESS = 1<<1,
 140     SW_PL_NEAR  = 1<<2,
 141     SW_MN_NEAR  = 1<<3,
 142     SW_KEY_R    = 1<<4,
 143     SW_KEY_G    = 1<<5,
 144     SW_KEY_B    = 1<<6,
 145   }
 146
 147   static struct MapThing {
 148     // thing flags
 149     enum : ushort {
 150       DirRight   = 0x0001,
 151       DeathMatch = 0x0010, // ÐÏÑ×ÌÑÅÔÓÑ ÔÏÌØËÏ × DeathMatch'Å
 152     }
 153
 154     short x, y;   // ËÏÏÒÄÉÎÁÔÙ
 155     ushort type;  // ÔÉÐ
 156     ushort flags; // ÆÌÁÇÉ
 157
 158     @property const pure nothrow @safe @nogc {
 159       bool left () => ((flags&DirRight) == 0);
 160       bool right () => ((flags&DirRight) != 0);
 161       bool dmonly () => ((flags&DeathMatch) != 0);
 162     }
 163   }
 164
 165   static struct MapSwitch {
 166     ubyte x, y;  // ËÏÏÒÄÉÎÁÔÙ/8
 167     ubyte type;  // ÔÉÐ
 168     ubyte tm;    // ÄÏÌÖÎÏ ÂÙÔØ 0
 169     ubyte a, b;  // ÏÂÙÞÎÏ - ËÏÏÒÄÉÎÁÔÙ/8 Ä×ÅÒÉ
 170     ushort c;    // ÎÅ ÉÓÐÏÌØÚÕÅÔÓÑ (×ÒÏÄÅ ÂÙ)
 171     ubyte flags; // ÆÌÁÇÉ (SW_*)
 172   }
 173
 174 public:
 175   enum { Type, Front, Back, AllLiquids, LiquidMask, LightMask, MapTexturesMax } // tile types, Front+: megatexture types
 176   ubyte[][3] tiles; // Type, Front, Back
 177   string[] wallnames; // "_water_0": water, "_water_1": acid, "_water_2": lava
 178   ubyte[] walltypes; // bit0: solid/non-solid(0x01); bit1: 0x02 if "vtrap01"
 179   D2DImage[] textures;
 180   int width, height;
 181   Texture[MapTexturesMax] texgl;
 182   TrueColorImage[MapTexturesMax] teximgs;
 183   D2DImage skytex;
 184   Texture skytexgl;
 185
 186   MapThing[] things;
 187   MapSwitch[] switches;
 188
 189   this () {}
 190
 191   this (string fname) { load(fname); }
 192   this(ST) (auto ref ST fl) { load(fl); }
 193
 194   bool hasLiquidAt (int x, int y) {
 195     if (x < 0 || y < 0 || x >= MapSize || y >= MapSize) return false;
 196     auto tt = tiles.ptr[Front].ptr[y*MapSize+x];
 197     return (wallnames[tt] == "_water_0" || wallnames[tt] == "_water_1" || wallnames[tt] == "_water_2");
 198   }
 199
 200   //FIXME: recreate textures cleanly
 201   void clearMegaTextures () {
 202     //foreach (Texture tex; texgl) if (tex !is null) tex.clear;
 203     //texgl[] = null;
 204   }
 205
 206   // build OpenGL "megatextures" with the whole level on it
 207   void oglBuildMega (uint buildMask=0xffff_ffffu) {
 208     if (skytexgl is null) skytexgl = new Texture(skytex.img, Texture.Option.Linear, Texture.Option.Repeat);
 209     //auto img = new TrueColorImage(width*TileSize, height*TileSize);
 210     foreach (immutable type; Front..LightMask+1) {
 211       if (teximgs[type] is null) {
 212         buildMask |= 1<<type;
 213         teximgs[type] = new TrueColorImage(width*TileSize, height*TileSize);
 214       }
 215       if ((buildMask&(1<<type)) == 0) continue;
 216       auto img = teximgs[type];
 217       img.imageData.colors[] = Color(0, 0, 0, 0);
 218       if (type == Back) {
 219         /*
 220         foreach (int y; 0..(height*TileSize+skytex.height-1)/skytex.height) {
 221           foreach (int x; 0..(width*TileSize+skytex.width-1)/skytex.width) {
 222             img.putTile(x*skytex.width, y*skytex.height, skytex);
 223           }
 224         }
 225         */
 226       }
 227       foreach (int y; 0..height) {
 228         foreach (int x; 0..width) {
 229           if (type == LightMask) {
 230             // in the lightmask texture, we should have only occluders' pixels
 231             auto tt = tiles.ptr[Type].ptr[y*MapSize+x];
 232             if ((tt&0x80) == 0 && (tt == TILE_WALL || tt == TILE_DOORC)) {
 233               img.putTile(x*TileSize, y*TileSize, textures.ptr[tiles.ptr[Back].ptr[y*MapSize+x]]);
 234               img.putTile(x*TileSize, y*TileSize, textures.ptr[tiles.ptr[Front].ptr[y*MapSize+x]]);
 235             } /*else if (tt != TILE_LIFTU && tt != TILE_LIFTD) {
 236               img.putTile(x*TileSize, y*TileSize, textures.ptr[tiles.ptr[Front].ptr[y*MapSize+x]]);
 237             }*/
 238           } else if (type == AllLiquids) {
 239             // texture with liquid background, for distortion
 240             auto tt = tiles.ptr[Front].ptr[y*MapSize+x];
 241             if (wallnames[tt] == "_water_0" || wallnames[tt] == "_water_1" || wallnames[tt] == "_water_2") {
 242               tt = tiles.ptr[Back].ptr[y*MapSize+x];
 243               img.putTile(x*TileSize, y*TileSize, textures.ptr[tt]);
 244               foreach (int dy; 0..TileSize) {
 245                 foreach (int dx; 0..TileSize) {
 246                   //img.putPixel(x*TileSize+dx, y*TileSize+dy, Color((tt == 3 ? 128 : 0), (tt == 2 ? 128 : 0), (tt == 1 ? 128 : 0), 128));
 247                   auto c = img.getPixel(x*TileSize+dx, y*TileSize+dy);
 248                   if (c.a == 0) img.putPixel(x*TileSize+dx, y*TileSize+dy, Color(0, 0, 0, 255));
 249                 }
 250               }
 251             }
 252           } else if (type == LiquidMask) {
 253             // texture with liquid colors, will be blended on top of the level
 254             auto tt = tiles.ptr[Front].ptr[y*MapSize+x];
 255             auto wclr = Color(0, 0, 0, 0);
 256                  if (wallnames[tt] == "_water_0") wclr = Color(0, 0, 100, 128); // water
 257             else if (wallnames[tt] == "_water_1") wclr = Color(24, 140, 0, 128); // acid
 258             else if (wallnames[tt] == "_water_2") wclr = Color(160, 0, 0, 128); // lava
 259             if (wclr.a) {
 260               img.putPixelTile(x*TileSize, y*TileSize, wclr);
 261               // if this is top one, make some light border
 262               if (!hasLiquidAt(x, y-1)) {
 263                 // border
 264                 auto wcc = wclr.lighten(0.6);
 265                 wcc.a = wclr.a;
 266                 foreach (int dx; 0..TileSize) img.putPixel(x*TileSize+dx, y*TileSize+0, wcc);
 267                 wcc = wclr.lighten(0.4);
 268                 wcc.a = wclr.a;
 269                 foreach (int dx; 0..TileSize) img.putPixel(x*TileSize+dx, y*TileSize+1, wcc);
 270                 wcc = wclr.lighten(0.2);
 271                 wcc.a = wclr.a;
 272                 foreach (int dx; 0..TileSize) img.putPixel(x*TileSize+dx, y*TileSize+2, wcc);
 273               }
 274             }
 275           } else {
 276             auto tf = tiles.ptr[Front].ptr[y*MapSize+x];
 277             auto tb = tiles.ptr[Back].ptr[y*MapSize+x];
 278             auto tt = tiles.ptr[type].ptr[y*MapSize+x];
 279             if (wallnames[tf] == "_water_0" || wallnames[tf] == "_water_1" || wallnames[tf] == "_water_2" ||
 280                 wallnames[tb] == "_water_0" || wallnames[tb] == "_water_1" || wallnames[tb] == "_water_2") {
 281             } else {
 282               img.putTile(x*TileSize, y*TileSize, textures.ptr[tt]);
 283             }
 284           }
 285         }
 286       }
 287       /*{
 288         import std.string : format;
 289         import arsd.png : writePng;
 290         writePng("zpng%02s.png".format(type), img);
 291       }*/
 292       if (texgl[type] is null) {
 293         texgl[type] = new Texture(img, (type == LightMask ? Texture.Option./*Linear*/Nearest : Texture.Option.Nearest), Texture.Option.Clamp);
 294       } else {
 295         texgl[type].setFromImage(img, 0, 0);
 296       }
 297     }
 298   }
 299
 300   void clear () {
 301     tiles[] = null;
 302     wallnames = null;
 303     walltypes = null;
 304     textures = null;
 305     foreach (Texture tex; texgl) if (tex !is null) tex.clear;
 306     texgl[] = null;
 307     skytex = null;
 308     things = null;
 309     switches = null;
 310   }
 311
 312   void dump (int idx) {
 313     static char to62 (ubyte b) { pragma(inline, true); return cast(char)(b < 10 ? '0'+b : (b-10 < 26 ? 'A'+(b-10) : 'a'+(b-10-26))); }
 314     foreach (immutable y; 0..MapSize) {
 315       foreach (immutable x; 0..MapSize) {
 316         conwrite(to62(tiles[idx][y*MapSize+x]));
 317       }
 318       conwriteln;
 319     }
 320   }
 321
 322   // true: found
 323   bool getThingPos (ushort id, int* x=null, int* y=null, ushort* flags=null) {
 324     foreach (ref th; things[]) {
 325       if (th.type == id) {
 326         if (x !is null) *x = th.x;
 327         if (y !is null) *y = th.y;
 328         if (flags !is null) *flags = th.flags;
 329         return true;
 330       }
 331     }
 332     if (x !is null) *x = 0;
 333     if (y !is null) *y = 0;
 334     if (flags !is null) *flags = 0;
 335     return false;
 336   }
 337
 338 private:
 339   void calcMapSize () {
 340     /*
 341     bool isEmpty(string dir) (int x, int y) if (dir == "col" || dir == "row") {
 342       while (x < MapSize && y < MapSize) {
 343         if (tiles[0][y*MapSize+x] || tiles[1][y*MapSize+x] || tiles[2][y*MapSize+x]) return false;
 344         static if (dir == "row") ++x; else ++y;
 345       }
 346       return true;
 347     }
 348     width = height = MapSize;
 349     // fix width
 350     while (width > 0 && isEmpty!"col"(width-1, 0)) --width;
 351     // fix height
 352     while (height > 0 && isEmpty!"row"(0, height-1)) --height;
 353     */
 354     width = height = MapSize;
 355   }
 356
 357   void load (string fname) {
 358     load(VFile(fname));
 359   }
 360
 361   void load(ST) (auto ref ST st) if (isReadableStream!ST) {
 362     clear();
 363     scope(failure) clear;
 364
 365     char[8] sign;
 366     st.rawReadExact(sign[]);
 367     if (sign != "Doom2D\x1a\x00") throw new Exception("invalid map signature");
 368     if (st.readNum!ushort() != MapVersion) throw new Exception("invalid map version");
 369
 370     // load map blocks
 371     foreach (ref a; tiles[]) a = new ubyte[](MapSize*MapSize);
 372     char[$] skyname = "sprites/sky/rsky1.vga";
 373     for (;;) {
 374       auto btype = st.readNum!ushort();
 375       if (btype == MB_END) break; // no more blocks
 376       auto bsubtype = st.readNum!ushort();
 377       auto bsize = st.readNum!uint();
 378       if (bsize == 0) continue; // skip this block, it has no data (wtf?!)
 379       // various tile types
 380       switch (btype) {
 381         case MB_SKY:
 382           if (bsize != 2) throw new Exception("invalid sky data size");
 383           ushort num = st.readNum!ushort();
 384           if (num >= 1 && num <= 3) skyname[$-5] = cast(char)('0'+num);
 385           break;
 386         case MB_BACK:
 387         case MB_FRONT:
 388         case MB_WTYPE:
 389           if (bsubtype > 1) throw new Exception("unknown tile block subtype");
 390           int idx = (btype == MB_BACK ? Back : (btype == MB_FRONT ? Front : Type));
 391           //ubyte[MapSize*MapSize] data = 0;
 392           auto data = tiles[idx];
 393           if (bsubtype == 0) {
 394             if (bsize != data.length) throw new Exception("invalid tile data size");
 395             st.rawReadExact(data[]);
 396           } else {
 397             // unpack RLE data
 398             auto pkdata = new ubyte[](bsize);
 399             st.rawReadExact(pkdata[]);
 400             int spos = 0, opos = 0;
 401             while (spos < pkdata.length) {
 402               ubyte b = pkdata[spos++];
 403               if (b != 255) {
 404                 data[opos++] = b;
 405               } else {
 406                 int count = pkdata[spos++];
 407                 count |= pkdata[spos++]<<8;
 408                 b = pkdata[spos++];
 409                 while (count-- > 0) data[opos++] = b;
 410               }
 411             }
 412             assert(opos == data.length);
 413           }
 414           // copy unpacked data
 415           //foreach (immutable y; 0..MapSize) tiles[idx][y*MapSize] = data[y*MapSize..(y+1)*MapSize];
 416           break;
 417         case MB_WALLNAMES:
 418           wallnames.length = 0;
 419           wallnames ~= null;
 420           //wallnames[] = null;
 421           //walltypes.length = 0;
 422           while (bsize >= 8+1) {
 423             char[8] texname = 0;
 424             st.rawReadExact(texname[]);
 425             auto type = st.readNum!ubyte();
 426             //char[] tn;
 427             string tns;
 428             foreach (char ch; texname) {
 429               if (ch == 0) break;
 430               if (ch >= 'A' && ch <= 'Z') ch += 32;
 431               ch = dos2koi8(ch);
 432               tns ~= ch;
 433               //tn = texname[0..idx+1];
 434             }
 435             import std.uni : toLower;
 436             wallnames ~= koi8lotranslit(tns).toLower;
 437             type = (type ? 1 : 0);
 438             if (wallnames[$-1] == "vtrap01") type |= 0x02;
 439             //wallnames ~= recodeToKOI8(recode(tn.idup, "utf-8", "cp866").toLower, "utf-8");
 440             //debug { conwriteln(wallnames.length-1, " : ", wallnames[$-1]); }
 441             //if (wallnames[$-1][$-1] == '_') wallnames[$-1] ~= "1";
 442             //wallnames[$-1] ~= ".vga";
 443             //conwriteln(wallnames[$-1]);
 444             walltypes ~= type;
 445             bsize -= 8+1;
 446           }
 447           if (bsize != 0) throw new Exception("invalid texture chunk size");
 448           debug { conwriteln(wallnames.length, " textures loaded"); }
 449           break;
 450         case MB_THING:
 451           while (bsize >= 8) {
 452             bsize -= 8;
 453             MapThing t = void;
 454             t.x = st.readNum!short();
 455             t.y = st.readNum!short();
 456             t.type = st.readNum!ushort();
 457             t.flags = st.readNum!ushort();
 458             if (t.type != 0) things ~= t;
 459           }
 460           if (bsize != 0) throw new Exception("invalid thing chunk size");
 461           break;
 462         case MB_SWITCH2:
 463           while (bsize >= 9) {
 464             bsize -= 9;
 465             MapSwitch sw = void;
 466             sw.x = st.readNum!ubyte();
 467             sw.y = st.readNum!ubyte();
 468             sw.type = st.readNum!ubyte();
 469             sw.tm = st.readNum!ubyte();
 470             sw.a = st.readNum!ubyte();
 471             sw.b = st.readNum!ubyte();
 472             sw.c = st.readNum!ushort();
 473             sw.flags = st.readNum!ubyte();
 474             switches ~= sw;
 475           }
 476           if (bsize != 0) throw new Exception("invalid thing chunk size");
 477           break;
 478         default:
 479           auto pkdata = new ubyte[](bsize);
 480           st.rawReadExact(pkdata[]);
 481           break;
 482       }
 483     }
 484     calcMapSize();
 485     // load textures
 486     textures.length = 0;
 487     foreach (immutable idx, string name; wallnames) {
 488       if (name.length == 0 || name[0] == '_') {
 489         textures ~= null;
 490         continue;
 491       } else {
 492         textures ~= new D2DImage("tilegfx/"~name~".vga");
 493       }
 494     }
 495     assert(textures.length == wallnames.length);
 496     // fix tiles
 497     foreach (immutable y; 0..height) {
 498       foreach (immutable x; 0..width) {
 499         if (tiles[Front][y*MapSize+x] >= textures.length) tiles[Front][y*MapSize+x] = 0;
 500         if (tiles[Back][y*MapSize+x] >= textures.length) tiles[Back][y*MapSize+x] = 0;
 501       }
 502     }
 503     skytex = new D2DImage(skyname.idup);
 504     //skytex = new D2DImage("sprites/rsky3.vga");
 505     skytex.removeOffset();
 506     debug { conwriteln(width, "x", height); }
 507   }
 508 }