"ESC c" as M-c (Meta+c, 8th bit set) when nethack [False]
obtains a command from player's keyboard.
-Boolean option if USE_TILES was set at compile time (MSDOS protected mode):
+Boolean option if TILES_IN_GLYPHMAP set at compile time (MSDOS):
preload_tiles control whether tiles get pre-loaded into RAM at [True]
the start of the game. Doing so enhances performance
of the tile graphics, but uses more memory.
/* End of Section 4 */
#ifdef TTY_TILES_ESCCODES
-# ifndef USE_TILES
-# define USE_TILES
+# ifndef TILES_IN_GLYPHMAP
+# define TILES_IN_GLYPHMAP
# endif
#endif
char *config_section_current;
boolean chosen_symset_start;
boolean chosen_symset_end;
-
+
/* invent.c */
/* for perm_invent when operating on a partial inventory display, so that
persistent one doesn't get shrunk during filtering for item selection
/* mkmaze.c */
struct trap *wportal;
+ /* new */
+ struct win_settings wsettings; /* wintype.h */
+
boolean havestate;
unsigned long magic; /* validate that structure layout is preserved */
};
extern int wallcolors[];
#endif
-/* If USE_TILES is defined during build, this comes from the generated
- * tile.c, complete with appropriate tile references in the initialization.
- * Otherwise, it comes from display.c.
+/* If TILES_IN_GLYPHMAP is defined during build, this is defined
+ * in the generated tile.c, complete with appropriate tile references in
+ * the initialization. Otherwise, it gets defined in display.c.
*/
extern const glyph_info nul_glyphinfo;
#endif
extern const char *mon_pmname(struct monst *);
extern const char *obj_pmname(struct obj *);
+boolean mapxy_valid(coordxy x, coordxy y);
/* ### do_wear.c ### */
/* ### tile.c ### */
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
extern void substitute_tiles(d_level *);
#endif
#if defined(X11_GRAPHICS) || defined(QT_GRAPHICS) || defined(GNOME_GRAPHICS) \
|| defined(MSWIN_GRAPHICS)
#ifndef NO_TILE_C
-#ifndef USE_TILES
-#define USE_TILES /* glyphmap[] with prefilled tile mappings will be available */
+#ifndef TILES_IN_GLYPHMAP
+#define TILES_IN_GLYPHMAP
#endif
#endif
#endif
#if defined(AMII_GRAPHICS) || defined(GEM_GRAPHICS)
#ifndef NO_TILE_C
-#ifndef USE_TILES
-#define USE_TILES
+#ifndef TILES_IN_GLYPHMAP
+#define TILES_IN_GLYPHMAP
#endif
#endif
#endif
{ m, OptS_##sec, 0, b, opt_##a, s, OthrOpt, n, v, d, No, c, \
(boolean *) 0, &optfn_##a, al, z, (const char *) 0, On, On, 0 },
-/* this is not reliable because USE_TILES might be defined in a
- multi-interface binary but not apply to the current interface */
-#ifdef USE_TILES
+/* this is not reliable because TILES_IN_GLYPHMAP might be defined
+ * in a multi-interface binary but not apply to the current interface */
+#ifdef TILES_IN_GLYPHMAP
#define tiled_map_Def On
#define ascii_map_Def Off
#else
*/
#ifndef SUPPRESS_GRAPHICS
#if (defined(SCREEN_BIOS) || defined(SCREEN_DJGPPFAST)) && !defined(PC9800)
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
#define SCREEN_VGA /* Include VGA graphics routines in the build */
#define SCREEN_VESA
#endif
X11_map_symbol text[ROWNO][COLNO]; /* Actual displayed screen. */
#ifdef TEXTCOLOR
X11_color colors[ROWNO][COLNO]; /* Color of each character. */
+ X11_color framecolors[ROWNO][COLNO]; /* Color of background
+ behind text */
GC color_gcs[CLR_MAX], /* GC for each color */
inv_color_gcs[CLR_MAX]; /* GC for each inverse color */
#define copy_gc color_gcs[NO_COLOR]
unsigned short glyph;
unsigned short tileidx;
unsigned glyphflags;
+ uint32 framecolor;
};
struct tile_map_info_t {
#ifdef ENHANCED_SYMBOLS
extern void curses_putch(winid wid, int x, int y, int ch,
struct unicode_representation *u, int color,
- int attrs);
+ int framecolor, int attrs);
#else
extern void curses_putch(winid wid, int x, int y, int ch, int color,
- int attrs);
+ int framecolor, int attrs);
#endif
extern void curses_get_window_size(winid wid, int *height, int *width);
extern boolean curses_window_has_border(winid wid);
short curx, cury; /* current cursor position on the screen */
#ifdef TEXTCOLOR
int color; /* current color */
+ uint32 framecolor; /* current background color */
#endif
int attrs; /* attributes in effect */
int toplin; /* flag for topl stuff */
#endif
E int xputc(int);
E void xputs(const char *);
-#if defined(SCREEN_VGA) || defined(SCREEN_8514)
-E void xputg(const glyph_info *);
+#if defined(SCREEN_VGA) || defined(SCREEN_8514) || defined(SCREEN_VESA)
+E void xputg(const glyph_info *, const glyph_info *);
#endif
E void cl_end(void);
E void clear_screen(void);
#ifdef TEXTCOLOR
E void term_end_color(void);
E void term_start_color(int color);
+E void term_start_bgcolor(int color);
#endif /* TEXTCOLOR */
#ifdef ENHANCED_SYMBOLS
extern void term_start_24bitcolor(struct unicode_representation *);
typedef struct gi {
int glyph; /* the display entity */
int ttychar;
+ uint32 framecolor;
glyph_map gm;
} glyph_info;
#define GLYPH_INFO_P struct gi
/* #define CORE_INVENT */
+/* In a binary with multiple window interfaces linked in, this is
+ * a structure to track certain interface capabilities that cannot be
+ * statically done at compile time. Some of them can be toggled and
+ * the core needs to know if they are active or not at the time.
+ */
+
+enum win_display_modes {
+ wdmode_traditional = 0,
+ wdmode_tiled
+};
+
+struct win_settings {
+ enum win_display_modes wdmode;
+ uint32 map_frame_color;
+};
+
/* clang-format on */
#endif /* WINTYPE_H */
extern void display_map(struct Window *);
#endif
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
extern int maxmontile, maxobjtile, maxothtile; /* from tile.c */
#define MAXMONTILE maxmontile
#define MAXOBJTILE maxobjtile
#
! IF ("$(TILESUPPORT)"=="Y")
-TILFLG = $(CDEFINE)USE_TILES
+TILFLG = $(CDEFINE)TILES_IN_GLYPHMAP
! ELSE
TILFLG =
! ENDIF
# Flags.
#
# Debugging
-#CFLAGS = /Zi /DFUNCTION_LEVEL_LINKING /DUSE_TILES /DDLB
+#CFLAGS = /Zi /DFUNCTION_LEVEL_LINKING /DTILES_IN_GLYPHMAP /DDLB
#LFLAGS = /CODEVIEW /NOI/MAP /CPARM:1 /INFO
# Normal
LFLAGS = /NOI/MAP /CPARM:1 /INFO
-CFLAGS = /DFUNCTION_LEVEL_LINKING /DUSE_TILES /DDLB
+CFLAGS = /DFUNCTION_LEVEL_LINKING /DTILES_IN_GLYPHMAP /DDLB
SPECOPTS =
#
# Leaving MACHINE_CODE undefined will allow it to run
override TARGET_CFLAGS = -c -O $(TOOLARCH) \
-I../include -I../outdated/include \
-I../outdated/sys/amiga -I../win/share \
- $(LUAINCL) -DAMIGA -DUSE_TILES $(PDCURSESDEF) \
+ $(LUAINCL) -DAMIGA -DTILES_IN_GLYPHMAP $(PDCURSESDEF) \
-DCROSSCOMPILE -DCROSSCOMPILE_TARGET -DCROSS_TO_AMIGA \
-DAMIGA_VERSION_STRING=\""VER: NetHack 3.7.0\""
# -DMICRO -DPATHLEN=31 -DFILENAME=80
{ { { 0 } } }, /* gbuf */
UNDEFINED_VALUES, /* gbuf_start */
UNDEFINED_VALUES, /* gbug_stop */
+
/* do_name.c */
UNDEFINED_PTR, /* gloc_filter_map */
UNDEFINED_VALUE, /* gloc_filter_floodfill_match_glyph */
UNDEFINED_VALUE, /* wc */
/* mkmaze.c */
UNDEFINED_PTR, /* wportal */
+ /* new */
+ { wdmode_traditional, NO_COLOR }, /* wsettings */
+
TRUE, /* havestate*/
IVMAGIC /* w_magic used to validate that structure layout has been preserved */
};
static void display_warning(struct monst *);
static int check_pos(coordxy, coordxy, int);
-static int get_bk_glyph(coordxy x, coordxy y);
+static void get_bkglyph_and_framecolor(coordxy x, coordxy y, int *, uint32 *);
static int tether_glyph(coordxy, coordxy);
static void mimic_light_blocking(struct monst *);
#ifdef UNBUFFERED_GLYPHINFO
/* glyph, ttychar, { glyphflags, { sym.color, sym.symidx },
tileidx, u } */
static glyph_info no_ginfo = {
- NO_GLYPH, ' ', { MG_BADXY, { NO_COLOR, 0 }, 0
+ NO_GLYPH, ' ', NO_COLOR, { MG_BADXY, { NO_COLOR, 0 }, 0
#ifdef ENHANCED_SYMBOLS
, 0
#endif
#define Glyphinfo_at(x, y, glyph) glyphinfo_at(x, y, glyph)
#endif
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
extern const glyph_info nul_glyphinfo; /* tile.c */
#else
/* glyph, ttychar, { glyphflags, { sym.color, sym.symidx },
tileidx, 0} */
const glyph_info nul_glyphinfo = {
- NO_GLYPH, ' ',
+ NO_GLYPH, ' ', NO_COLOR,
{ /* glyph_map */
MG_UNEXPL,
{ NO_COLOR, SYM_UNEXPLORED + SYM_OFF_X },
};
#endif
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
extern glyph_map glyphmap[MAX_GLYPH]; /* from tile.c */
#else
glyph_map glyphmap[MAX_GLYPH] = {
for (y = 0; y < ROWNO; ++y)
for (x = 1; x < COLNO; ++x) {
glyph = glyph_at(x, y); /* not levl[x][y].glyph */
- bkglyphinfo.glyph = get_bk_glyph(x, y);
+ get_bkglyph_and_framecolor(x, y, &bkglyphinfo.glyph, &bkglyphinfo.framecolor);
print_glyph(WIN_MAP, x, y,
Glyphinfo_at(x, y, glyph), &bkglyphinfo);
}
static gbuf_entry nul_gbuf = {
0, /* gnew */
- { GLYPH_UNEXPLORED, (unsigned) ' ', /* glyphinfo.glyph */
+ { GLYPH_UNEXPLORED, (unsigned) ' ', NO_COLOR, /* glyphinfo.glyph */
/* glyphinfo.gm */
{ MG_UNEXPL, { (unsigned) NO_COLOR, 0 }, 0
#ifdef ENHANCED_SYMBOLS
for (x = start; x <= stop; x++) {
gptr = &gg.gbuf[y][x];
glyph = gptr->glyphinfo.glyph;
- if (force || glyph != GLYPH_UNEXPLORED) {
- bkglyphinfo.glyph = get_bk_glyph(x, y);
+ get_bkglyph_and_framecolor(x, y, &bkglyphinfo.glyph,
+ &bkglyphinfo.framecolor);
+ if (force || glyph != GLYPH_UNEXPLORED
+ || bkglyphinfo.framecolor != NO_COLOR) {
print_glyph(WIN_MAP, x, y,
Glyphinfo_at(x, y, glyph), &bkglyphinfo);
}
static int delay_flushing = 0;
register coordxy x, y;
glyph_info bkglyphinfo = nul_glyphinfo;
+ int bkglyph;
/* 3.7: don't update map, status, or perm_invent during save/restore */
if (suppress_map_output())
for (y = 0; y < ROWNO; y++) {
register gbuf_entry *gptr = &gg.gbuf[y][x = gg.gbuf_start[y]];
- for (; x <= gg.gbuf_stop[y]; gptr++, x++)
- if (gptr->gnew) {
- map_glyphinfo(x, y, get_bk_glyph(x, y), 0, &bkglyphinfo);
+ for (; x <= gg.gbuf_stop[y]; gptr++, x++) {
+ get_bkglyph_and_framecolor(x, y, &bkglyph, &bkglyphinfo.framecolor);
+ if (gptr->gnew
+ || (gw.wsettings.map_frame_color != NO_COLOR && bkglyphinfo.framecolor != NO_COLOR)) {
+ map_glyphinfo(x, y, bkglyph, 0, &bkglyphinfo); /* won't touch framecolor */
print_glyph(WIN_MAP, x, y,
Glyphinfo_at(x, y, gptr->glyph), &bkglyphinfo);
gptr->gnew = 0;
}
+ }
}
reset_glyph_bbox();
#endif
/*
- * This will be used to get the glyph for the background so that
- * it can potentially be merged into graphical window ports to
- * improve the appearance of stuff on dark room squares and the
- * plane of air etc.
- *
- * Until that is working correctly in the branch, however, for now
- * we just return NO_GLYPH as an indicator to ignore it.
- *
+ * Get the glyph for the background so that it can potentially
+ * be merged into graphical window ports to improve the appearance
+ * of stuff on dark room squares and the plane of air etc.
* [This should be using background as recorded for #overview rather
* than current data from the map.]
+ *
+ * Also get the frame color to use for highlighting the map location
+ * for some purpose.
+ *
*/
-static int
-get_bk_glyph(coordxy x, coordxy y)
+static void
+get_bkglyph_and_framecolor(coordxy x, coordxy y, int *bkglyph, uint32 *framecolor)
{
- int idx, bkglyph = GLYPH_UNEXPLORED;
+ int idx, tmp_bkglyph = GLYPH_UNEXPLORED;
struct rm *lev = &levl[x][y];
if (iflags.use_background_glyph && lev->seenv != 0
idx = (flags.dark_room && iflags.use_color)
? DARKROOMSYM : S_stone;
}
-
if (idx != S_room)
- bkglyph = cmap_to_glyph(idx);
+ tmp_bkglyph = cmap_to_glyph(idx);
}
- return bkglyph;
+ if (gw.wsettings.map_frame_color != NO_COLOR && framecolor && mapxy_valid(x, y))
+ *framecolor = gw.wsettings.map_frame_color;
+ else
+ *framecolor = NO_COLOR;
+
+ *bkglyph = tmp_bkglyph;
}
-#if defined(USE_TILES) && defined(MSDOS)
+#if defined(TILES_IN_GLYPHMAP) && defined(MSDOS)
#define HAS_ROGUE_IBM_GRAPHICS \
(gc.currentgraphics == ROGUESET && SYMHANDLING(H_IBM) && !iflags.grmode)
#else
#include "hack.h"
static char *nextmbuf(void);
+static void getpos_getvalids_selection(struct selectionvar *, boolean (*)(coordxy, coordxy));
+static void selection_force_newsyms(struct selectionvar *);
static void getpos_help_keyxhelp(winid, const char *, const char *, int);
static void getpos_help(boolean, const char *);
static int QSORTCALLBACK cmp_coord_distu(const void *, const void *);
void (*gp_hilitef)(int),
boolean (*gp_getvalidf)(coordxy, coordxy))
{
+ boolean was_valid = (getpos_getvalid != NULL);
+ struct selectionvar *sel = selection_new();
+
+ getpos_getvalids_selection(sel, getpos_getvalid);
getpos_hilitefunc = gp_hilitef;
getpos_getvalid = gp_getvalidf;
+ getpos_getvalids_selection(sel, getpos_getvalid);
+ gw.wsettings.map_frame_color = (getpos_getvalid != NULL) ? CLR_BLUE : NO_COLOR;
+ if ((boolean) (getpos_getvalid != NULL) != was_valid)
+ selection_force_newsyms(sel);
+ selection_free(sel, TRUE);
+}
+
+boolean
+mapxy_valid(coordxy x, coordxy y)
+{
+ if (getpos_getvalid)
+ return (*getpos_getvalid)(x, y);
+ return FALSE;
+}
+
+static void
+getpos_getvalids_selection(struct selectionvar *sel, boolean (*validf)(coordxy, coordxy))
+{
+ coordxy x, y;
+
+ if (!sel || !validf)
+ return;
+
+ for (x = 1; x < sel->wid; x++)
+ for (y = 0; y < sel->hei; y++)
+ if ((*validf)(x, y))
+ selection_setpoint(x, y, sel, 1);
+}
+
+static void
+selection_force_newsyms(struct selectionvar *sel)
+{
+ coordxy x, y;
+
+ for (x = 1; x < sel->wid; x++)
+ for (y = 0; y < sel->hei; y++)
+ if (selection_getpoint(x, y, sel))
+ newsym_force(x, y);
}
static const char *const gloc_descr[NUM_GLOCS][4] = {
for (i = 0; i < NUM_GLOCS; i++)
if (garr[i])
free((genericptr_t) garr[i]);
- getpos_hilitefunc = (void (*)(int)) 0;
- getpos_getvalid = (boolean (*)(coordxy, coordxy)) 0;
+ getpos_sethilite(NULL, NULL);
u.dx = udx, u.dy = udy, u.dz = udz;
return result;
}
static struct win_information window_opts[] = {
#ifdef TTY_GRAPHICS
{ "tty",
- /* testing 'USE_TILES' here would bring confusion because it could
+ /* testing 'TILES_IN_GLYPHMAP' here would bring confusion because it could
apply to another interface such as X11, so check MSDOS explicitly
instead; even checking TTY_TILES_ESCCODES would probably be
confusing to most users (and it will already be listed separately
static int QSORTCALLBACK discovered_cmp(const genericptr, const genericptr);
static char *oclass_to_name(char, char *);
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
extern glyph_map glyphmap[MAX_GLYPH];
static void shuffle_tiles(void);
glyphmap[i + GLYPH_OBJ_PILETOP_OFF].tileidx = tmp_tilemap[1][i];
}
}
-#endif /* USE_TILES */
+#endif /* TILES_IN_GLYPHMAP */
static void
setgemprobs(d_level* dlev)
/* shuffle descriptions */
shuffle_all();
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
shuffle_tiles();
#endif
objects[WAN_NOTHING].oc_dir = rn2(2) ? NODIR : IMMEDIATE;
}
}
}
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
shuffle_tiles();
#endif
}
gs.showsyms[i] = go.ov_rogue_syms[i] ? go.ov_rogue_syms[i]
: gr.rogue_syms[i];
-#if defined(MSDOS) && defined(USE_TILES)
+#if defined(MSDOS) && defined(TILES_IN_GLYPHMAP)
if (iflags.grmode)
tileview(FALSE);
#endif
gs.showsyms[i] = go.ov_primary_syms[i] ? go.ov_primary_syms[i]
: gp.primary_syms[i];
-#if defined(MSDOS) && defined(USE_TILES)
+#if defined(MSDOS) && defined(TILES_IN_GLYPHMAP)
if (iflags.grmode)
tileview(TRUE);
#endif
LFLAGS =
# Debugging
-#cflags = -g -c $(INCLDIR) $(DLBFLG) $(CURSESDEF) -DUSE_TILES
+#cflags = -g -c $(INCLDIR) $(DLBFLG) $(CURSESDEF) -DTILES_IN_GLYPHMAP
#LFLAGS = -g
# Normal
-cflags = -c -O $(INCLDIR) $(DLBFLG) $(CURSESDEF) -DUSE_TILES
+cflags = -c -O $(INCLDIR) $(DLBFLG) $(CURSESDEF) -DTILES_IN_GLYPHMAP
LFLAGS =
#==========================================
static char *getdta(void);
#endif
static unsigned int dos_ioctl(int, int, unsigned);
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
extern boolean pckeys(unsigned char, unsigned char); /* pckeys.c */
#endif
else
ch = kpad[scan - KEYPADLO].normal;
}
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
/* Check for special interface manipulation keys */
if (pckeys(scan, shift)) {
ch = 0xFF;
#include "hack.h"
#ifdef MSDOS
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
#include "wintty.h"
#include "pcvideo.h"
vesa_refresh();
#endif
}
-#endif /* USE_TILES */
+#endif /* TILES_IN_GLYPHMAP */
#endif /* MSDOS */
/*pckeys.c*/
#include "hack.h"
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
#if defined(__GO32__) || defined(__DJGPP__)
#include <unistd.h>
return 0;
}
#endif
-#endif /* USE_TILES */
+#endif /* TILES_IN_GLYPHMAP */
/* pctiles.c */
*
*/
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
#ifndef TILE_X
#define TILE_X 16
#endif
#ifdef PACKED_FILE
extern int ReadPackedTileFile(int, char (*)[TILE_X]);
#endif
-#endif /* USE_TILES */
+#endif /* TILES_IN_GLYPHMAP */
/* pctiles.h */
extern void vga_tty_startup(int *, int *);
extern void vga_xputs(const char *, int, int);
extern void vga_xputc(char, int);
-extern void vga_xputg(const glyph_info *);
+extern void vga_xputg(const glyph_info *, const glyph_info *);
extern void vga_userpan(enum vga_pan_direction);
extern void vga_overview(boolean);
extern void vga_traditional(boolean);
extern void vesa_tty_startup(int *, int *);
extern void vesa_xputs(const char *, int, int);
extern void vesa_xputc(char, int);
-extern void vesa_xputg(const glyph_info *);
+extern void vesa_xputg(const glyph_info *, const glyph_info *);
extern void vesa_userpan(enum vga_pan_direction);
extern void vesa_overview(boolean);
extern void vesa_traditional(boolean);
int attrib_gr_normal; /* graphics mode normal attribute */
int attrib_text_intense; /* text mode intense attribute */
int attrib_gr_intense; /* graphics mode intense attribute */
+uint32 curframecolor = NO_COLOR; /* current background text color */
boolean traditional = FALSE; /* traditonal TTY character mode */
boolean inmap = FALSE; /* in the map window */
#ifdef TEXTCOLOR
#endif
#ifdef SCREEN_VESA
} else if (iflags.usevesa) {
- vesa_clear_screen(BACKGROUND_VGA_COLOR);
+ vesa_clear_screen(BACKGROUND_VESA_COLOR);
#endif
}
}
default:
g_attribute = iflags.grmode ? attrib_gr_normal : attrib_text_normal;
}
+ curframecolor = NO_COLOR;
}
void
term_end_color(void)
{
g_attribute = iflags.grmode ? attrib_gr_normal : attrib_text_normal;
+ curframecolor = NO_COLOR;
}
void
#endif
}
+void
+term_start_bgcolor(int bgcolor)
+{
+ // pline("before bgcolor = %d, curframecolor = %d", bgcolor, curframecolor);
+#ifdef TEXTCOLOR
+ if (!monoflag) {
+ if (bgcolor >= 0 && bgcolor < CLR_MAX)
+ curframecolor = bgcolor;
+ }
+#endif
+ // pline("after bgcolor = %d, curframecolor = %d", bgcolor, curframecolor);
+}
+
void
term_start_raw_bold(void)
{
char attribute;
i = iflags.grmode ? attrib_gr_normal : attrib_text_normal;
-
attribute = (char) ((g_attribute == 0) ? i : g_attribute);
+
+ if (curframecolor != NO_COLOR) {
+ attribute |= ((ttycolors[curframecolor]) << 4);
+ }
+
if (!iflags.grmode) {
txt_xputc(ch, attribute);
#ifdef SCREEN_VGA
}
/* write out a glyph picture at current location */
-void xputg(const glyph_info *glyphinfo)
+void xputg(const glyph_info *glyphinfo, const glyph_info *bkglyphinfo)
{
if (!iflags.grmode || !iflags.tile_view) {
(void) xputc((char) glyphinfo->ttychar);
#ifdef SCREEN_VGA
} else if (iflags.grmode && iflags.usevga) {
- vga_xputg(glyphinfo);
+ vga_xputg(glyphinfo, bkglyphinfo);
#endif
#ifdef SCREEN_VESA
} else if (iflags.grmode && iflags.usevesa) {
- vesa_xputg(glyphinfo);
+ vesa_xputg(glyphinfo, bkglyphinfo);
#endif
}
}
extern int total_tiles_used, Tile_corr, Tile_unexplored; /* from tile.c */
struct VesaCharacter {
- uint32 colour;
+ uint32 colour, bgcolour;
uint32 chr;
};
uint32 attr;
unsigned special;
short int tileidx;
+ int framecolor;
} map[ROWNO][COLNO]; /* track the glyphs */
#define vesa_clearmap() \
for (x = 0; x < COLNO; ++x) { \
map[y][x].glyph = GLYPH_UNEXPLORED; \
map[y][x].ch = glyph2ttychar(GLYPH_UNEXPLORED); \
+ map[y][x].framecolor = NO_COLOR; \
map[y][x].attr = 0; \
map[y][x].special = 0; \
map[y][x].tileidx = Tile_unexplored; \
vesa_gotoloc(col, row);
}
-#if defined(USE_TILES)
+#if defined(TILES_IN_GLYPHMAP)
/* Place tile represent. a glyph at current location */
void
-vesa_xputg(const glyph_info *glyphinfo)
+vesa_xputg(const glyph_info *glyphinfo, const glyph_info *bkglyphinfo UNUSED)
{
int glyphnum = glyphinfo->glyph;
uint32 ch = (uchar) glyphinfo->ttychar;
map[ry][col].special = special;
map[ry][col].tileidx = glyphinfo->gm.tileidx;
map[ry][col].attr = attr;
+
+ if (bkglyphinfo->framecolor != NO_COLOR) {
+ map[ry][col].framecolor = bkglyphinfo->framecolor;
+ }
+
if (iflags.traditional_view) {
vesa_WriteChar(ch, col, row, attr);
} else {
++col;
vesa_gotoloc(col, row);
}
-#endif /* USE_TILES */
+#endif /* TILES_IN_GLYPHMAP */
/*
* Cursor location manipulation, and location information fetching
currow = min(row, LI - 1);
}
-#if defined(USE_TILES) && defined(CLIPPING)
+#if defined(TILES_IN_GLYPHMAP) && defined(CLIPPING)
static void
vesa_cliparound(int x, int y)
{
free(p_row);
}
-#endif /* USE_TILES && CLIPPING */
+#endif /* TILES_IN_GLYPHMAP && CLIPPING */
+
void
vesa_userpan(enum vga_pan_direction pan)
if (inited) return;
inited = TRUE;
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
/*
* Attempt to open the required tile files. If we can't
* don't perform the video mode switch, use TTY code instead.
windowprocs.wincap2 |= WC2_U_24BITCOLOR;
}
#endif
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
paletteptr = get_palette();
iflags.tile_view = TRUE;
iflags.over_view = FALSE;
chr_cache_size = 0;
}
+extern uint32 curframecolor; /* video.c */
+
static void
vesa_WriteTextRow(int pixx, int pixy, struct VesaCharacter const *t_row,
unsigned t_row_width)
unsigned long offset = pixy * (unsigned long)vesa_scan_line + pixx * vesa_pixel_bytes;
unsigned char fg[4], bg[4];
+#if 0
/* Preprocess the background color */
if (vesa_pixel_bytes == 1) {
bg[0] = BACKGROUND_VESA_COLOR;
bg[2] = (pix >> 16) & 0xFF;
bg[3] = (pix >> 24) & 0xFF;
}
+#endif
/* First loop: draw one raster line of all row entries */
for (py = 0; py < (int) vesa_char_height; ++py) {
for (i = 0; i < t_row_width; ++i) {
uint32 chr = t_row[i].chr;
uint32 colour = t_row[i].colour;
+
+ /* background color */
+ if (vesa_pixel_bytes == 1) {
+ bg[0] = BACKGROUND_VESA_COLOR;
+ } else {
+ unsigned long pix = vesa_palette[t_row[i].bgcolour];
+ bg[0] = pix & 0xFF;
+ bg[1] = (pix >> 8) & 0xFF;
+ bg[2] = (pix >> 16) & 0xFF;
+ bg[3] = (pix >> 24) & 0xFF;
+ }
/* Preprocess the foreground color */
if (colour & 0x80000000) {
fg[0] = colour & 0xFF;
/* First, try the VESA palette function */
/* Set the tile set and text colors */
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
for (i = 0; i < FIRST_TEXT_COLOR; ++i) {
p2[i*4 + 0] = palette[i].b >> shift;
p2[i*4 + 1] = palette[i].g >> shift;
/* If that didn't work, use the original BIOS function */
if (regs.x.ax != 0x004F) {
/* Set the tile set and text colors */
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
for (i = 0; i < FIRST_TEXT_COLOR; ++i) {
p2[i*3 + 0] = palette[i].r >> shift;
p2[i*3 + 1] = palette[i].g >> shift;
unsigned i;
/* Set the tile set and text colors */
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
if (palette != NULL) {
p = palette;
for (i = 0; i < FIRST_TEXT_COLOR; ++i) {
extern int attrib_text_intense; /* text mode intense attribute */
extern int attrib_gr_intense; /* graphics mode intense attribute */
extern boolean inmap; /* in the map window */
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
extern glyph_map glyphmap[MAX_GLYPH];
#endif
int attr;
unsigned special;
short int tileidx;
+ uint32 framecolor;
} map[ROWNO][COLNO]; /* track the glyphs */
extern int total_tiles_used, Tile_corr, Tile_unexplored; /* from tile.c */
for (x = 0; x < COLNO; ++x) { \
map[y][x].glyph = GLYPH_UNEXPLORED; \
map[y][x].ch = glyph2ttychar(GLYPH_UNEXPLORED); \
+ map[y][x].framecolor = NO_COLOR; \
map[y][x].attr = 0; \
map[y][x].special = 0; \
map[y][x].tileidx = Tile_unexplored; \
vga_gotoloc(col, row);
}
-#if defined(USE_TILES)
+#if defined(TILES_IN_GLYPHMAP)
/* Place tile represent. a glyph at current location */
void
-vga_xputg(const glyph_info *glyphinfo)
+vga_xputg(const glyph_info *glyphinfo,
+ const glyph_info *bkglyphinfo)
{
int glyphnum = glyphinfo->glyph;
uint32 ch = glyphinfo->ttychar;
attr = (g_attribute == 0) ? attrib_gr_normal : g_attribute;
map[ry][col].attr = attr;
map[ry][col].tileidx = glyphinfo->gm.tileidx;
+ if (bkglyphinfo->framecolor != NO_COLOR) {
+ map[ry][col].framecolor = bkglyphinfo->framecolor;
+ }
+
if (iflags.traditional_view) {
vga_WriteChar(ch, col, row, attr);
} else if (!iflags.over_view) {
++col;
vga_gotoloc(col, row);
}
-#endif /* USE_TILES */
+#endif /* TILES_IN_GLYPHMAP */
/*
* Cursor location manipulation, and location information fetching
currow = min(row, LI - 1);
}
-#if defined(USE_TILES) && defined(CLIPPING)
+#if defined(TILES_IN_GLYPHMAP) && defined(CLIPPING)
static void
vga_cliparound(int x, int y UNUSED)
{
}
}
}
-#endif /* USE_TILES && CLIPPING */
+#endif /* TILES_IN_GLYPHMAP && CLIPPING */
void
vga_userpan(enum vga_pan_direction pan)
int i;
const char *font_name;
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
const char *tile_file;
int tilefailure = 0;
/*
windowprocs.win_cliparound = vga_cliparound;
/* vga_NoBorder(BACKGROUND_VGA_COLOR); */ /* Not needed after palette
mod */
-#ifdef USE_TILES
+#ifdef TILES_IN_GLYPHMAP
paletteptr = get_palette();
iflags.tile_view = TRUE;
iflags.over_view = FALSE;
return 0;
}
+extern int curframecolor; /* video.c */
+
/*
* Write character 'ch', at (x,y) and
* do it using the colour 'colour'.
char __far *cp;
unsigned char fnt;
int actual_colour = vgacmap[colour];
+ int bgcolor;
int vplane;
unsigned char bitmap[ROWS_PER_CELL];
/* if (chr < ' ') chr = ' '; */ /* assumes ASCII set */
vga_GetBitmap(chr, bitmap);
+ if (curframecolor != NO_COLOR)
+ bgcolor = vgacmap[curframecolor];
+ else
+ bgcolor = BACKGROUND_VGA_COLOR;
+
x = min(col, (CO - 1)); /* min() used protection from callers */
pixy = min(row, (LI - 1)) * 16; /* assumes 8 x 16 char set */
-
- vplane = ~actual_colour & ~BACKGROUND_VGA_COLOR & 0xF;
+ vplane = ~actual_colour & ~bgcolor & 0xF;
if (vplane != 0) {
egawriteplane(vplane);
for (i = 0; i < MAX_ROWS_PER_CELL; ++i) {
WRITE_ABSOLUTE(cp, (char) 0x00);
}
}
- vplane = actual_colour & ~BACKGROUND_VGA_COLOR & 0xF;
+ vplane = actual_colour & ~bgcolor & 0xF;
if (vplane != 0) {
egawriteplane(vplane);
for (i = 0; i < MAX_ROWS_PER_CELL; ++i) {
WRITE_ABSOLUTE(cp, (char) fnt);
}
}
- vplane = ~actual_colour & BACKGROUND_VGA_COLOR & 0xF;
+ vplane = ~actual_colour & bgcolor & 0xF;
if (vplane != 0) {
egawriteplane(vplane);
for (i = 0; i < MAX_ROWS_PER_CELL; ++i) {
WRITE_ABSOLUTE(cp, (char) fnt);
}
}
- vplane = actual_colour & BACKGROUND_VGA_COLOR & 0xF;
+ vplane = actual_colour & bgcolor & 0xF;
if (vplane != 0) {
egawriteplane(vplane);
for (i = 0; i < MAX_ROWS_PER_CELL; ++i) {
override TARGET_STUBEDIT = ../lib/djgpp/i586-pc-msdosdjgpp/bin/stubedit
MSDOS_TARGET_CFLAGS = -c -O -I../include -I../sys/msdos -I../win/share \
$(LUAINCL) -DDLB $(PDCURSESDEF) \
- -DUSE_TILES -DCROSSCOMPILE -DCROSSCOMPILE_TARGET -DCROSS_TO_MSDOS \
+ -DTILES_IN_GLYPHMAP -DCROSSCOMPILE -DCROSSCOMPILE_TARGET \
+ -DCROSS_TO_MSDOS \
-Wall -Wextra -Wno-missing-field-initializers -Wreturn-type -Wunused \
-Wformat -Wswitch -Wshadow -Wwrite-strings \
-Wimplicit -Wimplicit-function-declaration -Wimplicit-int \
# * -c (which is included in cflagsBuild) substituted with -Fo$@
# * "-o $@ " is removed
# * win/X11/Window.o commented due to conflict with pdcurses
+# * win/share/cppregex.o commented out due to earlier rule
# * commented out $(TARGETPFX)tile.o: tile.c $(HACK_H)
# * commented out $(TARGETPFX)cppregex.o because it has its own rule already
# * $(TARGETPFX) becomes $(OTTY) in 1st batch with $(TTYDEF)
WORD attr;
long color24;
int color256idx;
+ const char *bkcolorseq;
const char *colorseq;
#endif /* VIRTUAL_TERMINAL_SEQUENCES */
} cell_t;
WORD foreground;
WORD attr;
int current_nhcolor;
+ int current_nhbkcolor;
int current_nhattr[ATR_INVERSE+1];
COORD cursor;
HANDLE hConOut;
(FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED), /* foreground */
0, /* attr */
0, /* current_nhcolor */
+ 0, /* current_nhbkcolor */
#endif /* VIRTUAL_TERMINAL_SEQUENCES */
{FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE},
#ifndef VIRTUAL_TERMINAL_SEQUENCES
#ifdef VIRTUAL_TERMINAL_SEQUENCES
long customcolors[CLR_MAX];
const char *esc_seq_colors[CLR_MAX];
+const char *esc_seq_bkcolors[CLR_MAX];
struct rgbvalues {
int idx;
static void
init_custom_colors(void)
{
+ char bkcolorbuf[32];
+
customcolors[CLR_BLACK] = rgbtable_to_long(&rgbtable[131]);
customcolors[CLR_RED] = rgbtable_to_long(&rgbtable[5]);
customcolors[CLR_GREEN] = rgbtable_to_long(&rgbtable[31]);
esc_seq_colors[CLR_BRIGHT_BLUE] = "\x1b[34m\x1b[94m";
esc_seq_colors[CLR_BRIGHT_MAGENTA] = "\x1b[35m\x1b[95m";
esc_seq_colors[CLR_BRIGHT_CYAN] = "\x1b[36m\x1b[96m";
+
+ /* Sprintf(tmp, "\033[%dm", ((color % 8) + 40)); */
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_BLACK % 8) + 40));
+ esc_seq_bkcolors[CLR_BLACK] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_RED % 8) + 40));
+ esc_seq_bkcolors[CLR_RED] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_GREEN % 8) + 40));
+ esc_seq_bkcolors[CLR_GREEN] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_YELLOW % 8) + 40));
+ esc_seq_bkcolors[CLR_YELLOW] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_BLUE % 8) + 40));
+ esc_seq_bkcolors[CLR_BLUE] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_MAGENTA % 8) + 40));
+ esc_seq_bkcolors[CLR_MAGENTA] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_CYAN % 8) + 40));
+ esc_seq_bkcolors[CLR_CYAN] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_WHITE % 8) + 40));
+ esc_seq_bkcolors[CLR_WHITE] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_BROWN % 8) + 40));
+ esc_seq_bkcolors[CLR_BROWN] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_GRAY % 8) + 40));
+ esc_seq_bkcolors[CLR_GRAY] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((NO_COLOR % 8) + 40));
+ esc_seq_bkcolors[NO_COLOR] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_ORANGE % 8) + 40));
+ esc_seq_bkcolors[CLR_ORANGE] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_BRIGHT_BLUE % 8) + 40));
+ esc_seq_bkcolors[CLR_BRIGHT_BLUE] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_BRIGHT_GREEN % 8) + 40));
+ esc_seq_bkcolors[CLR_BRIGHT_GREEN] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_BRIGHT_MAGENTA % 8) + 40));
+ esc_seq_bkcolors[CLR_BRIGHT_MAGENTA] = dupstr(bkcolorbuf);
+ Snprintf(bkcolorbuf, sizeof bkcolorbuf, "\x1b[%dm", ((CLR_BRIGHT_CYAN % 8) + 40));
+ esc_seq_bkcolors[CLR_BRIGHT_CYAN] = dupstr(bkcolorbuf);
}
void emit_start_bold(void);
/* Console buffer flipping support */
#ifdef VIRTUAL_TERMINAL_SEQUENCES
enum do_flags {
- do_utf8_content = 1,
- do_wide_content = 2,
- do_colorseq = 4,
- do_color24 = 8,
- do_newattr = 16
+ do_utf8_content = 0x01,
+ do_wide_content = 0x02,
+ do_colorseq = 0x04,
+ do_color24 = 0x08,
+ do_newattr = 0x10,
+ do_bkcolorseq = 0x20,
};
enum did_flags {
- did_utf8_content = 1,
- did_wide_content = 2,
- did_colorseq = 4,
- did_color24 = 8,
- did_newattr = 16
+ did_utf8_content = 0x01,
+ did_wide_content = 0x02,
+ did_colorseq = 0x04,
+ did_color24 = 0x08,
+ did_newattr = 0x10,
+ did_bkcolorseq = 0x20,
};
static void
do_anything |= do_colorseq;
if (back->attr != front->attr)
do_anything |= do_newattr;
+ if (back->bkcolorseq != front->bkcolorseq)
+ do_anything |= do_bkcolorseq;
#ifdef UTF8_FROM_CORE
if (!SYMHANDLING(H_UTF8)) {
if (console.has_unicode
WriteConsoleA(console.hConOut, back->colorseq,
(int) strlen(back->colorseq), &unused,
&reserved);
- } else {
+ }
+ if (back->bkcolorseq) {
+ did_anything |= did_bkcolorseq;
+ WriteConsoleA(console.hConOut, back->bkcolorseq,
+ (int) strlen(back->bkcolorseq), &unused,
+ &reserved);
+ }
+ if ((did_anything | (did_colorseq | did_bkcolorseq | did_color24)) == 0) {
+ did_anything &= ~(did_bkcolorseq | did_color24);
did_anything |= did_colorseq;
emit_default_color();
}
/* this causes way too much performance degradation */
/* cell.color24 = customcolors[console.current_nhcolor]; */
cell.colorseq = esc_seq_colors[console.current_nhcolor];
+ cell.bkcolorseq = esc_seq_bkcolors[console.current_nhbkcolor];
cell.attr = console.attr;
// if (console.color24)
// __debugbreak();
#else
cell.attr = console.attr;
cell.colorseq = esc_seq_colors[console.current_nhcolor];
+ cell.bkcolorseq = esc_seq_bkcolors[console.current_nhbkcolor];
cell.color24 = console.color24 ? console.color24 : 0L;
cell.color256idx = 0;
wch[1] = 0;
cell_t cell;
cell.attr = console.attr;
cell.colorseq = esc_seq_colors[console.current_nhcolor];
+ cell.bkcolorseq = esc_seq_bkcolors[console.current_nhbkcolor];
cell.color24 = console.color24 ? console.color24 : 0L;
cell.color256idx =console.color256idx ? console.color256idx : 0;
Snprintf((char *) cell.utf8str, sizeof cell.utf8str, "%s",
console.current_nhcolor = NO_COLOR;
}
+void
+term_start_bgcolor(int color)
+{
+#ifdef TEXTCOLOR
+ if (color >= 0 && color < CLR_MAX) {
+ console.current_nhbkcolor = color;
+ } else
+#endif
+ console.current_nhbkcolor = NO_COLOR;
+}
+
void
term_end_color(void)
{
console.attr = (console.foreground | console.background);
#endif /* ! VIRTUAL_TERMINAL_SEQUENCES */
console.current_nhcolor = NO_COLOR;
+ console.current_nhbkcolor = NO_COLOR;
}
void
/* the locale */
if (console.localestr)
free(console.localestr);
- console.localestr = strdup(setlocale(LC_ALL, ".UTF8"));
+ console.localestr = dupstr(setlocale(LC_ALL, ".UTF8"));
/* the code page */
SetConsoleOutputCP(65001);
console.code_page = GetConsoleOutputCP();
if (localestr) {
if (console.localestr)
free(console.localestr);
- console.localestr = strdup(localestr);
+ console.localestr = dupstr(localestr);
}
set_known_good_console_font();
/* the console mode */
if (tmplocalestr) {
if (console.localestr)
free(console.localestr);
- console.localestr = strdup(tmplocalestr);
+ console.localestr = dupstr(tmplocalestr);
}
success = SetConsoleOutputCP(console.orig_code_page);
#endif /* VIRTUAL_TERMINAL_SEQUENCES */
if (localestr) {
if (console.localestr)
free(console.localestr);
- console.localestr = strdup(localestr);
+ console.localestr = dupstr(localestr);
}
console.code_page = console.orig_code_page;
if (console.has_unicode) {
#else
{ "USER_SOUNDS", 0 },
#endif
-#if defined(USE_TILES)
- { "USE_TILES", 1 },
+#if defined(TILES_IN_GLYPHMAP)
+ { "TILES_IN_GLYPHMAP", 1 },
#else
- { "USE_TILES", 0 },
+ { "TILES_IN_GLYPHMAP", 0 },
#endif
#if defined(VAR_PLAYGROUND)
{ "VAR_PLAYGROUND", 1 },
QT_GRAPHICS GNOME_GRAPHICS GEM_GRAPHICS/;
# Game Features:
-@feature = qw/ZEROCOMP USE_TILES ASCIIGRAPH CLIPPING TEXTCOLOR
+@feature = qw/ZEROCOMP TILES_IN_GLYPHMAP ASCIIGRAPH CLIPPING TEXTCOLOR
COMPRESS ZLIB_COMP RANDOM SECURE USER_SOUNDS
SAFERHANGUP MFLOPPY NOCWD_ASSUMPTIONS
VAR_PLAYGROUND DLB SHELL SUSPEND NOSAVEONHANGUP HANGUPHANDLING
if (color < CLR_MAX && hilites[color] && *hilites[color])
xputs(hilites[color]);
}
+
+void
+term_start_bgcolor(int color)
+{
+ char tmp[8];
+ Sprintf(tmp, "\033[%dm", ((color % 8) + 40));
+ xputs(tmp);
+}
#endif /* TEXTCOLOR */
#ifdef ENHANCED_SYMBOLS
char defmorestr[] = "--More--";
#ifdef CLIPPING
-#if defined(USE_TILES) && defined(MSDOS)
+#if defined(TILES_IN_GLYPHMAP) && defined(MSDOS)
boolean clipping = FALSE; /* clipping on? */
int clipx = 0, clipxmax = 0;
int clipy = 0, clipymax = 0;
#endif
#endif /* CLIPPING */
-#if defined(USE_TILES) && defined(MSDOS)
+#if defined(TILES_IN_GLYPHMAP) && defined(MSDOS)
extern void adjust_cursor_flags(struct WinDesc *);
#endif
iflags.wc2_statuslines = 2;
newwin->offx = 0;
rowoffset = ttyDisplay->rows - iflags.wc2_statuslines;
-#if defined(USE_TILES) && defined(MSDOS)
+#if defined(TILES_IN_GLYPHMAP) && defined(MSDOS)
if (iflags.grmode) {
newwin->offy = rowoffset;
} else
print_vt_code2(AVTC_SELECT_WINDOW, window);
-#if defined(USE_TILES) && defined(MSDOS)
+#if defined(TILES_IN_GLYPHMAP) && defined(MSDOS)
adjust_cursor_flags(cw);
#endif
cw->curx = --x; /* column 0 is never used */
#ifdef CLIPPING
if (y < (int) cw->offy || y + clipy > ROWNO)
continue; /* only refresh board */
-#if defined(USE_TILES) && defined(MSDOS)
+#if defined(TILES_IN_GLYPHMAP) && defined(MSDOS)
if (iflags.tile_view)
row_refresh((xmin / 2) + clipx - ((int) cw->offx / 2), COLNO - 1,
y + clipy - (int) cw->offy);
winid window,
coordxy x, coordxy y,
const glyph_info *glyphinfo,
- const glyph_info *bkglyphinfo UNUSED)
+ const glyph_info *bkglyphinfo)
{
boolean inverse_on = FALSE, colordone = FALSE, glyphdone = FALSE;
int ch, color;
BW_LAVA and BW_ICE won't ever be set when color is on;
(tried bold for ice but it didn't look very good; inverse is easier
to see although the Valkyrie quest ends up being hard on the eyes) */
- if (((special & MG_PET) != 0 && iflags.hilite_pet)
+ if (iflags.use_color
+ && bkglyphinfo && bkglyphinfo->framecolor != NO_COLOR) {
+#ifdef TEXTCOLOR
+ ttyDisplay->framecolor = bkglyphinfo->framecolor;
+ term_start_bgcolor(bkglyphinfo->framecolor);
+#endif
+ } else if (((special & MG_PET) != 0 && iflags.hilite_pet)
|| ((special & MG_OBJPILE) != 0 && iflags.hilite_pile)
|| ((special & MG_FEMALE) != 0 && wizard && iflags.wizmgender)
|| ((special & (MG_DETECT | MG_BW_LAVA | MG_BW_ICE | MG_BW_SINK)) != 0
inverse_on = TRUE;
}
-#if defined(USE_TILES) && defined(MSDOS)
+#if defined(TILES_IN_GLYPHMAP) && defined(MSDOS)
if (iflags.grmode && iflags.tile_view) {
- xputg(glyphinfo);
+ xputg(glyphinfo, bkglyphinfo);
glyphdone = TRUE;
}
#endif
/* turn off color as well, turning off ATR_INVERSE may have done
this already and if so, we won't know the current state unless
we do it explicitly */
- if (ttyDisplay->color != NO_COLOR) {
+ if (ttyDisplay->color != NO_COLOR || ttyDisplay->framecolor != NO_COLOR) {
term_end_color();
- ttyDisplay->color = NO_COLOR;
+ ttyDisplay->color = ttyDisplay->framecolor = NO_COLOR;
}
#endif
#ifdef ENHANCED_SYMBOLS
ttyDisplay->curx++; /* the real cursor moved too */
}
+#ifdef NO_TERMS /* termcap.o isn't linked in */
+#if !defined(MSDOS) && !defined(WIN32)
+void
+term_start_bgcolor(int color)
+{
+ /* placeholder for now */
+}
+#endif /* !MSDOS && !WIN32 */
+#endif /* NO_TERMS */
+
void
tty_raw_print(const char *str)
{
projects / nethack / commitdiff