nethack-gwaa-kiwi/nethack
1
0
Fork 0
Code Pull Requests Activity
Files
84bf23640c407b4bb0900cc596ba1eb7c72fdafb
nethack/win/share/tile2bmp.c
T
nhmall de842ec483 add a set of decals to stock tileset 
win/share/decals.txt contains (initially) a decal_delimiter tile,
a decal_pet tile, and a decal_pile tile.
The latter two can be used for hilite_pet and hilite_pile implementations
that don't have something in place already. The implementation would
just need to apply (merge) the non-background decal pixels over a
regular tile.

The special decal_delimiter tile can be used to confirm the presence
of the delimiter tiles in the tileset and mark the end of the regular tiles,
and the start of the decal tiles.
   row 1 contains the background color whose pixels should be
   ignored when applying a decal to a tile.
   row 2 contains a row of pixels colored (0, 0, 0).
   row 3 contains a row of pixels colored pure green (0, 255, 0).
   row 3 contains a row of pixels colored pure blue  (0, 0, 255).
2026-07-29 20:47:50 -04:00

396 lines
11 KiB
C
Raw Blame History

/* NetHack 5.0 tile2bmp.c $NHDT-Date: 1781973098 2026/06/20 16:31:38 $ $NHDT-Branch: NetHack-5.0 $:$NHDT-Revision: 1.53 $ */
/* Copyright (c) NetHack PC Development Team 1995 */
/* NetHack may be freely redistributed. See license for details. */
/*
* Edit History:
*
* Initial Creation M.Allison 1994/01/11
* 256 colour bmp and statue support M.Allison 2015/04/19
*
*/
#ifndef __GNUC__
#include "win32api.h"
#endif
#include "config.h"
#include "hacklib.h"
#include "tile.h"
extern void monst_globals_init(void);
extern void objects_globals_init(void);
static int examine_tilefiles(void);
static int set_tilefile_path(const char *, const char *, char *, size_t);
#if defined(_MSC_VER) && defined(_WIN64)
#define UNALIGNED_POINTER __unaligned
#else
#define UNALIGNED_POINTER
#endif
#define COLORS_IN_USE 256
#define BITCOUNT 8
/* GCC fix by Paolo Bonzini 1999/03/28 */
#ifdef __GNUC__
#define PACK __attribute__((packed))
#else
#define PACK
#endif
static short
leshort(short x)
{
#ifdef __BIG_ENDIAN__
return ((x & 0xff) << 8) | ((x >> 8) & 0xff);
#else
return x;
#endif
}
static int32_t
lelong(int32_t x)
{
#ifdef __BIG_ENDIAN__
return ((x & 0xff) << 24) | ((x & 0xff00) << 8) | ((x >> 8) & 0xff00)
| ((x >> 24) & 0xff);
#else
return x;
#endif
}
#ifdef __GNUC__
typedef struct tagBMIH {
uint32_t biSize;
int32_t biWidth;
int32_t biHeight;
uint16_t biPlanes;
uint16_t biBitCount;
uint32_t biCompression;
uint32_t biSizeImage;
int32_t biXPelsPerMeter;
int32_t biYPelsPerMeter;
uint32_t biClrUsed;
uint32_t biClrImportant;
} PACK BITMAPINFOHEADER;
typedef struct tagBMFH {
uint16_t bfType;
uint32_t bfSize;
uint16_t bfReserved1;
uint16_t bfReserved2;
uint32_t bfOffBits;
} PACK BITMAPFILEHEADER;
typedef struct tagRGBQ {
uint8_t rgbBlue;
uint8_t rgbGreen;
uint8_t rgbRed;
uint8_t rgbReserved;
} PACK RGBQUAD;
#define BI_RGB 0L
#define BI_RLE8 1L
#define BI_RLE4 2L
#define BI_BITFIELDS 3L
#endif /* __GNUC__ */
#define RGBQUAD_COUNT 256
#pragma pack(1)
struct tagBMP {
BITMAPFILEHEADER bmfh;
BITMAPINFOHEADER bmih;
RGBQUAD bmaColors[RGBQUAD_COUNT];
uchar packtile; /* start */
} PACK bmp, *newbmp;
#pragma pack()
FILE *tibfile2;
pixel tilepixels[TILE_Y][TILE_X];
static void build_bmfh(BITMAPFILEHEADER *);
static void build_bmih(UNALIGNED_POINTER BITMAPINFOHEADER *);
static void build_bmptile(pixel(*) [TILE_X]);
#define TILESETS 1
static const char *const relative_tiledir = "../win/share/";
/* monsters must be first because main uses it twice */
const char *const tilefilenames[TILESETS][5] = {
{ "monsters.txt", "objects.txt", "other.txt",
"monsters.txt", "decals.txt" },
};
int tilecnt[SIZE(tilefilenames[0])];
int tilefileset = 0;
int tiles_counted;
int max_x, max_y;
int magictileno = 0, bmpsize;
int num_colors = 0;
int max_tiles_in_row = 40;
int tiles_in_row;
int filenum;
int initflag;
int pass;
int yoffset, xoffset;
char bmpname[128];
FILE *fp;
DISABLE_WARNING_UNREACHABLE_CODE
int
main(int argc, char *argv[])
{
int i, j, number_of_rows, number_in_final_row;
uchar *c;
char tilefile_full_path[256] = { 0 };
if (argc != 2) {
Fprintf(stderr, "usage: %s outfile.bmp\n", argv[0]);
exit(EXIT_FAILURE);
} else if (argv[1] == 0 || strlen(argv[1]) >= sizeof bmpname - 1) {
Fprintf(stderr, "invalid output bmp file name %s, aborting.\n",
argv[0]);
exit(EXIT_FAILURE);
} else {
strcpy(bmpname, argv[1]);
}
objects_globals_init();
monst_globals_init();
/* tilefileset = (TILE_X == 64) ? 2 : (TILE_X == 32) ? 1 : 0; */
tilefileset = 0;
if (!examine_tilefiles()) {
Fprintf(stderr, "unable to open all of the tile files, aborting.\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < SIZE(tilecnt); ++i)
magictileno += tilecnt[i];
/* count monsters twice for grayscale variation */
magictileno += tilecnt[0];
max_x = TILE_X * max_tiles_in_row;
max_y = ((TILE_Y * magictileno) / max_tiles_in_row) + TILE_Y;
bmpsize = (sizeof bmp - sizeof bmp.packtile)
+ (max_y * (max_x * sizeof(uchar)));
newbmp = malloc(bmpsize);
if (!newbmp) {
printf("memory allocation failure, %d %d, aborting.\n",
bmpsize, magictileno);
exit(EXIT_FAILURE);
}
tiles_counted = 0;
xoffset = yoffset = 0;
initflag = 0;
filenum = 0;
pass = 0;
fp = fopen(bmpname, "wb");
if (!fp) {
printf("Error creating tile file %s, aborting.\n", bmpname);
exit(EXIT_FAILURE);
}
filenum = 0;
while (pass < SIZE(tilefilenames[tilefileset])) {
if (!set_tilefile_path(relative_tiledir,
tilefilenames[tilefileset][filenum],
tilefile_full_path, sizeof tilefile_full_path)) {
Fprintf(stderr, "tile2bmp path issue %s %s %d\n",
relative_tiledir, tilefilenames[tilefileset][filenum],
(int) sizeof tilefile_full_path);
exit(EXIT_FAILURE);
}
if (!fopen_text_file(tilefile_full_path, RDTMODE)) {
Fprintf(stderr, "usage: tile2bmp (from the util directory)\n");
exit(EXIT_FAILURE);
}
num_colors = colorsinmap;
if (num_colors > 62) {
Fprintf(stderr, "too many colors (%d), aborting.\n", num_colors);
exit(EXIT_FAILURE);
}
if (!initflag) {
UNALIGNED_POINTER BITMAPINFOHEADER *bmih;
build_bmfh(&bmp.bmfh);
bmih = &bmp.bmih;
build_bmih(bmih);
for (i = 0; i < num_colors; i++) {
bmp.bmaColors[i].rgbRed = ColorMap[CM_RED][i];
bmp.bmaColors[i].rgbGreen = ColorMap[CM_GREEN][i];
bmp.bmaColors[i].rgbBlue = ColorMap[CM_BLUE][i];
bmp.bmaColors[i].rgbReserved = 0;
}
*newbmp = bmp;
for (i = 0; i < max_y; ++i)
for (j = 0; j < max_x; ++j) {
c = &newbmp->packtile + ((i * max_x) + j);
*c = (uchar) 0;
}
initflag = 1;
}
set_grayscale(pass == 3);
/* printf("Colormap initialized\n"); */
while (read_text_tile(tilepixels)) {
if (tiles_counted >= magictileno) {
Fprintf(stderr, "tile2bmp: more than %d tiles!\n",
magictileno);
exit(EXIT_FAILURE);
}
build_bmptile(tilepixels);
tiles_counted++;
xoffset += TILE_X;
if (xoffset >= max_x) {
yoffset += TILE_Y;
xoffset = 0;
}
}
(void) fclose_text_file();
++pass;
++filenum;
}
fwrite(newbmp, bmpsize, 1, fp);
fclose(fp);
number_of_rows = tiles_counted / max_tiles_in_row;
number_in_final_row = tiles_counted % max_tiles_in_row;
Fprintf(stderr, "Total of %d tiles written to %s, "
"%d full rows of %d tiles",
tiles_counted, bmpname,
number_of_rows, max_tiles_in_row);
if (number_in_final_row != 0) {
Fprintf(stderr, ", final row %d has %d tile%s",
number_of_rows + 1, number_in_final_row,
number_in_final_row > 1 ? "s" : "");
}
(void) fputs(".\n\n", stderr);
free((genericptr_t) newbmp);
exit(EXIT_SUCCESS);
/*NOTREACHED*/
return 0;
}
RESTORE_WARNINGS
static void
build_bmfh(BITMAPFILEHEADER* pbmfh)
{
pbmfh->bfType = leshort(0x4D42);
pbmfh->bfSize = lelong(bmpsize);
pbmfh->bfReserved1 = (uint32_t) 0;
pbmfh->bfReserved2 = (uint32_t) 0;
pbmfh->bfOffBits = lelong(sizeof bmp.bmfh + sizeof bmp.bmih
+ (RGBQUAD_COUNT * sizeof(RGBQUAD)));
}
static void
build_bmih(UNALIGNED_POINTER BITMAPINFOHEADER* pbmih)
{
uint16_t cClrBits;
int w, h;
pbmih->biSize = lelong(sizeof(bmp.bmih));
pbmih->biWidth = lelong(w = max_x);
pbmih->biHeight = lelong(h = max_y);
pbmih->biPlanes = leshort(1);
pbmih->biBitCount = leshort(8);
cClrBits = 8;
if (cClrBits == 1)
cClrBits = 1;
else if (cClrBits <= 4)
cClrBits = 4;
else if (cClrBits <= 8)
cClrBits = 8;
else if (cClrBits <= 16)
cClrBits = 16;
else if (cClrBits <= 24)
cClrBits = 24;
else
cClrBits = 32;
pbmih->biCompression = lelong(BI_RGB);
pbmih->biXPelsPerMeter = lelong(0);
pbmih->biYPelsPerMeter = lelong(0);
#if (TILE_X == 32)
if (cClrBits < 24)
pbmih->biClrUsed = lelong(1 << cClrBits);
#else
pbmih->biClrUsed = lelong(RGBQUAD_COUNT);
#endif
pbmih->biSizeImage = lelong(((w * cClrBits + 31) & ~31) / 8 * h);
pbmih->biClrImportant = (uint32_t) 0;
}
static void
build_bmptile(pixel(*pixels)[TILE_X])
{
int cur_x, cur_y, cur_color, apply_color;
int x, y;
uchar *c;
for (cur_y = 0; cur_y < TILE_Y; cur_y++) {
for (cur_x = 0; cur_x < TILE_X; cur_x++) {
for (cur_color = 0; cur_color < num_colors; cur_color++) {
if (ColorMap[CM_RED][cur_color] == pixels[cur_y][cur_x].r
&& ColorMap[CM_GREEN][cur_color] == pixels[cur_y][cur_x].g
&& ColorMap[CM_BLUE][cur_color] == pixels[cur_y][cur_x].b)
break;
}
if (cur_color >= num_colors)
Fprintf(stderr, "color not in colormap! (tile #%d)\n",
tiles_counted);
y = (max_y - 1) - (cur_y + yoffset);
apply_color = cur_color;
x = cur_x + xoffset;
c = &newbmp->packtile + ((y * max_x) + x);
*c = (uchar) apply_color;
}
}
}
static int
set_tilefile_path(const char *fdir, const char *fname, char *buf, size_t sz)
{
size_t consuming = 0;
*buf = '\0';
consuming = strlen(fdir) + strlen(fname) + 1;
if (consuming > sz)
return 0;
Strcpy(buf, fdir);
Strcat(buf, fname);
return 1;
}
static int
examine_tilefiles(void)
{
FILE *fp2;
int i, tiles_in_file;
char tilefile_full_path[256];
for (i = 0; i < SIZE(tilefilenames[0]); ++i) {
tiles_in_file = 0;
if (!set_tilefile_path(relative_tiledir,
tilefilenames[tilefileset][i],
tilefile_full_path,
sizeof tilefile_full_path)) {
Fprintf(stderr, "tile2bmp path issue %s/%s %d\n",
relative_tiledir, tilefilenames[tilefileset][i],
(int) sizeof tilefile_full_path);
return 0;
}
fp2 = fopen(tilefile_full_path, "r");
if (fp2) {
char line[256];
while (fgets(line, sizeof line, fp2)) {
if (!strncmp(line, "# tile ", 7))
tiles_in_file++;
}
(void) fclose(fp2);
tilecnt[i] = tiles_in_file;
}
}
return 1;
}
/*tile2bmp.c*/
View Git Blame Copy Permalink