sys/msdos/tile2bin.c

   1 /* aNetHack 0.0.1       tile2bin.c      $ANH-Date: 1457207041 2016/03/05 19:44:01 $  $ANH-Branch: chasonr $:$ANH-Revision: 1.9 $ */
   2 /*   Copyright (c) aNetHack PC Development Team 1993, 1994, 1995     */
   3 /*   aNetHack may be freely redistributed.  See license for details. */
   4
   5 /*
   6  * Edit History:
   7  *
   8  *      Initial Creation                        M.Allison       93/10/21
   9  *      ifndef MONITOR_HEAP for heaputil.c      P.Winner        94/03/12
  10  *      added Borland C _stklen variable        Y.Sapir         94/05/01
  11  *      fixed to use text tiles from win/share  M.Allison       95/01/31
  12  *
  13  */
  14
  15 #include "hack.h"
  16 #include "pcvideo.h"
  17 #include "tile.h"
  18 #include "pctiles.h"
  19
  20 #include <dos.h>
  21 #ifndef MONITOR_HEAP
  22 #include <stdlib.h>
  23 #endif
  24 #include <time.h>
  25
  26 #ifdef __GO32__
  27 #include <unistd.h>
  28 #endif
  29
  30 #if defined(_MSC_VER) && _MSC_VER >= 700
  31 #pragma warning(disable : 4309) /* initializing */
  32 #pragma warning(disable : 4018) /* signed/unsigned mismatch */
  33 #pragma warning(disable : 4131) /* old style declarator */
  34 #pragma warning(disable : 4127) /* conditional express. is constant */
  35 #endif
  36
  37 #ifdef __BORLANDC__
  38 extern unsigned _stklen = STKSIZ;
  39 #endif
  40
  41 /* Produce only a planar file if building the overview file; with packed
  42    files, we can make overview-size tiles on the fly */
  43 #if defined(OVERVIEW_FILE) && defined(PACKED_FILE)
  44 #undef PACKED_FILE
  45 #endif
  46
  47 extern char *FDECL(tilename, (int, int));
  48
  49 #ifdef PLANAR_FILE
  50 char masktable[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
  51 char charcolors[MAXCOLORMAPSIZE];
  52 #ifdef OVERVIEW_FILE
  53 struct overview_planar_cell_struct planetile;
  54 #else
  55 struct planar_cell_struct planetile;
  56 #endif
  57 FILE *tibfile1;
  58 #endif
  59
  60 #ifdef PACKED_FILE
  61 char packtile[TILE_Y][TILE_X];
  62 FILE *tibfile2;
  63 #endif
  64
  65 int num_colors;
  66 pixel pixels[TILE_Y][TILE_X];
  67 struct tibhdr_struct tibheader;
  68
  69 static void FDECL(write_tibtile, (int));
  70 static void FDECL(write_tibheader, (FILE *, struct tibhdr_struct *));
  71 static void FDECL(build_tibtile, (pixel(*) [TILE_X], BOOLEAN_P));
  72 static void NDECL(remap_colors);
  73
  74 #ifndef OVERVIEW_FILE
  75 char *tilefiles[] = { "../win/share/monsters.txt", "../win/share/objects.txt",
  76                       "../win/share/other.txt" };
  77 #else
  78 char *tilefiles[] = { "../win/share/monthin.txt", "../win/share/objthin.txt",
  79                       "../win/share/oththin.txt" };
  80 #endif
  81
  82 int tilecount;
  83 int filenum;
  84 int paletteflag;
  85
  86 int
  87 main(argc, argv)
  88 int argc;
  89 char *argv[];
  90 {
  91     int i;
  92     struct tm *newtime;
  93     time_t aclock;
  94     char *paletteptr;
  95     unsigned num_monsters = 0;
  96
  97     if (argc != 1) {
  98         Fprintf(stderr, "usage: tile2bin (from the util directory)\n");
  99         exit(EXIT_FAILURE);
 100     }
 101
 102 #ifdef PLANAR_FILE
 103 #ifndef OVERVIEW_FILE
 104     tibfile1 = fopen(ANETHACK_PLANAR_TILEFILE, WRBMODE);
 105 #else
 106     tibfile1 = fopen(ANETHACK_OVERVIEW_TILEFILE, WRBMODE);
 107 #endif
 108     if (tibfile1 == (FILE *) 0) {
 109         Fprintf(stderr, "Unable to open output file %s\n",
 110 #ifndef OVERVIEW_FILE
 111                 ANETHACK_PLANAR_TILEFILE);
 112 #else
 113                 ANETHACK_OVERVIEW_TILEFILE);
 114 #endif
 115         exit(EXIT_FAILURE);
 116     }
 117 #endif
 118
 119 #ifdef PACKED_FILE
 120     tibfile2 = fopen(ANETHACK_PACKED_TILEFILE, WRBMODE);
 121     if (tibfile2 == (FILE *) 0) {
 122         Fprintf(stderr, "Unable to open output file %s\n",
 123                 ANETHACK_PACKED_TILEFILE);
 124         exit(EXIT_FAILURE);
 125     }
 126 #endif
 127     time(&aclock);
 128     newtime = localtime(&aclock);
 129
 130     tilecount = 0;
 131     paletteflag = 0;
 132     filenum = 0;
 133     while (filenum < 3) {
 134         if (!fopen_text_file(tilefiles[filenum], RDTMODE)) {
 135             Fprintf(stderr,
 136                     "usage: tile2bin (from the util or src directory)\n");
 137             exit(EXIT_FAILURE);
 138         }
 139         num_colors = colorsinmap;
 140         if (num_colors > 62) {
 141             Fprintf(stderr, "too many colors (%d)\n", num_colors);
 142             exit(EXIT_FAILURE);
 143         }
 144
 145         if (!paletteflag) {
 146             remap_colors();
 147             paletteptr = tibheader.palette;
 148             for (i = 0; i < num_colors; i++) {
 149                 *paletteptr++ = ColorMap[CM_RED][i],
 150                 *paletteptr++ = ColorMap[CM_GREEN][i],
 151                 *paletteptr++ = ColorMap[CM_BLUE][i];
 152             }
 153             paletteflag++;
 154         }
 155
 156         while (read_text_tile(pixels)) {
 157             build_tibtile(pixels, FALSE);
 158             write_tibtile(tilecount);
 159             tilecount++;
 160         }
 161
 162         (void) fclose_text_file();
 163         if (filenum == 0) {
 164             num_monsters = tilecount;
 165         }
 166         ++filenum;
 167     }
 168
 169     /* Build the statue glyphs */
 170     if (!fopen_text_file(tilefiles[0], RDTMODE)) {
 171         Fprintf(stderr,
 172                 "usage: tile2bin (from the util or src directory)\n");
 173         exit(EXIT_FAILURE);
 174     }
 175
 176     while (read_text_tile(pixels)) {
 177         build_tibtile(pixels, TRUE);
 178         write_tibtile(tilecount);
 179         tilecount++;
 180     }
 181
 182     (void) fclose_text_file();
 183
 184 #if defined(_MSC_VER)
 185     tibheader.compiler = MSC_COMP;
 186 #elif defined(__BORLANDC__)
 187     tibheader.compiler = BC_COMP;
 188 #elif defined(__GO32__)
 189     tibheader.compiler = DJGPP_COMP;
 190 #else
 191     tibheader.compiler = OTHER_COMP;
 192 #endif
 193
 194     strncpy(tibheader.ident, "aNetHack 0.0.1 MSDOS Port binary tile file", 80);
 195     strncpy(tibheader.timestamp, asctime(newtime), 24);
 196     tibheader.timestamp[25] = '\0';
 197     tibheader.tilecount = tilecount;
 198     tibheader.numcolors = num_colors;
 199 #ifdef PLANAR_FILE
 200     tibheader.tilestyle = PLANAR_STYLE;
 201     write_tibheader(tibfile1, &tibheader);
 202     (void) fclose(tibfile1);
 203 #ifndef OVERVIEW_FILE
 204     Fprintf(stderr, "Total of %d planar tiles written to %s.\n", tilecount,
 205             ANETHACK_PLANAR_TILEFILE);
 206 #else
 207     Fprintf(stderr, "Total of %d planar tiles written to %s.\n", tilecount,
 208             ANETHACK_OVERVIEW_TILEFILE);
 209 #endif
 210 #endif
 211
 212 #ifdef PACKED_FILE
 213     tibheader.tilestyle = PACKED_STYLE;
 214     write_tibheader(tibfile2, &tibheader);
 215     Fprintf(stderr, "Total of %d packed tiles written to %s.\n", tilecount,
 216             ANETHACK_PACKED_TILEFILE);
 217     (void) fclose(tibfile2);
 218 #endif
 219
 220     exit(EXIT_SUCCESS);
 221     /*NOTREACHED*/
 222     return 0;
 223 }
 224
 225 static void
 226 write_tibheader(fileptr, tibhdr)
 227 FILE *fileptr;
 228 struct tibhdr_struct *tibhdr;
 229 {
 230     if (fseek(fileptr, 0L, SEEK_SET)) {
 231         Fprintf(stderr, "Error writing header to tile file\n");
 232     }
 233     fwrite(tibhdr, sizeof(struct tibhdr_struct), 1, fileptr);
 234 }
 235
 236 static void
 237 build_tibtile(pixels, statues)
 238 pixel (*pixels)[TILE_X];
 239 boolean statues;
 240 {
 241     static int graymappings[] = {
 242         /* .  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  */
 243         0, 1, 17, 18, 19, 20, 27, 22, 23, 24, 25, 26, 21, 15, 13, 14, 14
 244     };
 245     int i, j, k, co_off;
 246     unsigned char co_mask, tmp;
 247
 248 #ifdef PLANAR_FILE
 249 #ifndef OVERVIEW_FILE
 250     memset((void *) &planetile, 0, sizeof(struct planar_cell_struct));
 251 #else
 252     memset((void *) &planetile, 0,
 253            sizeof(struct overview_planar_cell_struct));
 254 #endif
 255 #endif
 256     for (j = 0; j < TILE_Y; j++) {
 257         for (i = 0; i < TILE_X; i++) {
 258             for (k = 0; k < num_colors; k++) {
 259                 if (ColorMap[CM_RED][k] == pixels[j][i].r
 260                     && ColorMap[CM_GREEN][k] == pixels[j][i].g
 261                     && ColorMap[CM_BLUE][k] == pixels[j][i].b)
 262                     break;
 263             }
 264             if (k >= num_colors)
 265                 Fprintf(stderr, "color not in colormap!\n");
 266             if (statues) {
 267                 k = graymappings[k];
 268             } else {
 269                 if (k == 16) {
 270                     k = 13;
 271                 } else if (k == 13) {
 272                     k = 16;
 273                 }
 274             }
 275 #ifdef PACKED_FILE
 276             packtile[j][i] = k;
 277 #endif
 278
 279 #ifdef PLANAR_FILE
 280             if (i > 7) {
 281                 co_off = 1;
 282                 co_mask = masktable[i - 8];
 283             } else {
 284                 co_off = 0;
 285                 co_mask = masktable[i];
 286             }
 287
 288             if (!statues) {
 289                 if (k == 28) {
 290                     k = 0;
 291                 }
 292                 if (k >= 16) {
 293                     fprintf(stderr, "Warning: pixel value %d in 16 color bitmap\n", k);
 294                 }
 295             }
 296             tmp = planetile.plane[0].image[j][co_off];
 297             planetile.plane[0].image[j][co_off] =
 298                 (k & 0x0008) ? (tmp | co_mask) : (tmp & ~co_mask);
 299
 300             tmp = planetile.plane[1].image[j][co_off];
 301             planetile.plane[1].image[j][co_off] =
 302                 (k & 0x0004) ? (tmp | co_mask) : (tmp & ~co_mask);
 303
 304             tmp = planetile.plane[2].image[j][co_off];
 305             planetile.plane[2].image[j][co_off] =
 306                 (k & 0x0002) ? (tmp | co_mask) : (tmp & ~co_mask);
 307
 308             tmp = planetile.plane[3].image[j][co_off];
 309             planetile.plane[3].image[j][co_off] =
 310                 (k & 0x0001) ? (tmp | co_mask) : (tmp & ~co_mask);
 311 #endif /* PLANAR_FILE */
 312         }
 313     }
 314 }
 315
 316 static void
 317 write_tibtile(recnum)
 318 int recnum;
 319 {
 320     long fpos;
 321
 322 #ifdef PLANAR_FILE
 323 #ifndef OVERVIEW_FILE
 324     fpos = ((long) (recnum) * (long) sizeof(struct planar_cell_struct))
 325            + (long) TIBHEADER_SIZE;
 326 #else
 327     fpos =
 328         ((long) (recnum) * (long) sizeof(struct overview_planar_cell_struct))
 329         + (long) TIBHEADER_SIZE;
 330 #endif
 331     if (fseek(tibfile1, fpos, SEEK_SET)) {
 332         Fprintf(stderr, "Error seeking before planar tile write %d\n",
 333                 recnum);
 334     }
 335 #ifndef OVERVIEW_FILE
 336     fwrite(&planetile, sizeof(struct planar_cell_struct), 1, tibfile1);
 337 #else
 338     fwrite(&planetile, sizeof(struct overview_planar_cell_struct), 1,
 339            tibfile1);
 340 #endif
 341 #endif
 342
 343 #ifdef PACKED_FILE
 344     fpos =
 345         ((long) (recnum) * (long) sizeof(packtile)) + (long) TIBHEADER_SIZE;
 346     if (fseek(tibfile2, fpos, SEEK_SET)) {
 347         Fprintf(stderr, "Error seeking before packed tile write %d\n",
 348                 recnum);
 349     }
 350     fwrite(&packtile, sizeof(packtile), 1, tibfile2);
 351 #endif
 352 }
 353
 354 static void
 355 remap_colors()
 356 {
 357     char swap;
 358
 359     swap = ColorMap[CM_RED][13];
 360     ColorMap[CM_RED][13] = ColorMap[CM_RED][16];
 361     ColorMap[CM_RED][16] = swap;
 362     swap = ColorMap[CM_GREEN][13];
 363     ColorMap[CM_GREEN][13] = ColorMap[CM_GREEN][16];
 364     ColorMap[CM_GREEN][16] = swap;
 365     swap = ColorMap[CM_BLUE][13];
 366     ColorMap[CM_BLUE][13] = ColorMap[CM_BLUE][16];
 367     ColorMap[CM_BLUE][16] = swap;
 368 }