/*
 *********************************************************************
 *  File:       wpn-misc.h                                           *
 *  Summary:    temporary home for weapon f(x) until struct'ed       *
 *  Written by: don brodale <dbrodale@bigfootinteractive.com>        *
 *                                                                   *
 *  Changelog(most recent first):                                    *
 *                                                                   *
 *  <00>     12jun2000     dlb     created after little thought      *
 *********************************************************************
*/
#ifndef WPNMISC_H
#define WPNMISC_H
#include "externs.h"
/* ***********************************************************************
 * called from: food.h 
 * *********************************************************************** */
bool can_cut_meat(unsigned char wclass, unsigned char wtype);
/* ***********************************************************************
 * called from: acr - fight - food - item_use - itemname - spells2
 * *********************************************************************** */
char damage_type(unsigned char wclass, unsigned char wtype);
// last updated: 10jun2000 {dlb}
/* ***********************************************************************
 * called from: describe - fight - item_use
 * *********************************************************************** */
int hands_reqd_for_weapon(unsigned char wclass, unsigned char wtype);
// last updated: 10jun2000 {dlb}
/* ***********************************************************************
 * called from: dungeon - fight - item_use - randart
 * *********************************************************************** */
bool is_demonic(unsigned char weapon_subtype);
// last updated: 10jun2000 {dlb}
/* ***********************************************************************
 * called from: dungeon - item_use - mstuff2
 * *********************************************************************** */
unsigned char launched_by(unsigned char weapon_subtype);
// last updated: 10jun2000 {dlb}
/* ***********************************************************************
 * called from: describe - dungeon - fight - item_use - mstuff2 - randart -
 *              spells2 - spells3
 * *********************************************************************** */
bool launches_things( unsigned char weapon_subtype );
// last updated: 10jun2000 {dlb}
/* ***********************************************************************
 * called from: describe - fight - files - it_use3 - newgame - spells1
 * *********************************************************************** */
char weapon_skill(unsigned char wclass, unsigned char wtype);
#endif

/*
 *********************************************************************
 *  File:       wpn-misc.cc                                          *
 *  Summary:    temporary home for weapon f(x) until struct'ed       *
 *  Written by: don brodale <dbrodale@bigfootinteractive.com>        *
 *                                                                   *
 *  Changelog(most recent first):                                    *
 *                                                                   *
 *  <00>     12jun2000     dlb     created after little thought      *
 *********************************************************************
 */
#include "AppHdr.h"
#include "wpn-misc.h"
#include "externs.h"
// all of this will be replaced by a struct and data handlers {dlb}:
/*
 **************************************************
 *                                                *
 *             BEGIN PUBLIC FUNCTIONS             *
 *                                                *
 **************************************************
*/
char damage_type(unsigned char wclass, unsigned char wtype)
{
    char type_damage = DVORP_CRUSHING;  // this is the default, btw {dlb}
    if (wclass == OBJ_WEAPONS)
    {
        switch (wtype)
        {
        case WPN_DAGGER:
        case WPN_DEMON_BLADE:
        case WPN_DOUBLE_SWORD:
        case WPN_GREAT_SWORD:
        case WPN_KATANA:
        case WPN_KNIFE:
        case WPN_LONG_SWORD:
        case WPN_QUICK_BLADE:
        case WPN_SABRE:
        case WPN_FALCHION:
        case WPN_SCIMITAR:
        case WPN_SCYTHE:
        case WPN_SHORT_SWORD:
        case WPN_TRIPLE_SWORD:
            type_damage = DVORP_SLICING;
            break;
        case WPN_DEMON_TRIDENT:
        case WPN_EVENINGSTAR:
        case WPN_GIANT_SPIKED_CLUB:
        case WPN_MORNINGSTAR:
        case WPN_SPEAR:
        case WPN_SPIKED_FLAIL:
        case WPN_TRIDENT:
            type_damage = DVORP_PIERCING;
            break;
        case WPN_WAR_AXE:
        case WPN_BATTLEAXE:
        case WPN_BROAD_AXE:
        case WPN_EXECUTIONERS_AXE:
        case WPN_GLAIVE:
        case WPN_HALBERD:
        case WPN_HAND_AXE:
            type_damage = DVORP_CHOPPING;
            break;
        }
    }
    return (type_damage);
}                               // end damage_type()
bool can_cut_meat(unsigned char wclass, unsigned char wtype)
{
    int type = damage_type( wclass, wtype );
    if (type == DVORP_CHOPPING || type == DVORP_SLICING)
        return (true);
    return (false);
}
int hands_reqd_for_weapon(unsigned char wclass, unsigned char wtype)
{
    int reqd_hands = HANDS_ONE_HANDED;
    switch (wclass)
    {
    case OBJ_WEAPONS:
        switch (wtype)
        {
        case WPN_HALBERD:
        case WPN_SCYTHE:
        case WPN_GLAIVE:
        case WPN_QUARTERSTAFF:
        case WPN_BATTLEAXE:
        case WPN_EXECUTIONERS_AXE:
        case WPN_GREAT_SWORD:
        case WPN_TRIPLE_SWORD:
        case WPN_GREAT_MACE:
        case WPN_GREAT_FLAIL:
        case WPN_GIANT_CLUB:
        case WPN_GIANT_SPIKED_CLUB:
            reqd_hands = HANDS_TWO_HANDED;
            break;
        case WPN_SPEAR:
        case WPN_TRIDENT:
        case WPN_DEMON_TRIDENT:
        case WPN_WAR_AXE:
        case WPN_BROAD_AXE:
        case WPN_KATANA:
        case WPN_DOUBLE_SWORD:
            reqd_hands = HANDS_ONE_OR_TWO_HANDED;
            break;
        }
        break;
    case OBJ_STAVES:
        reqd_hands = HANDS_TWO_HANDED;
        break;
    }
    return (reqd_hands);
}                               // end hands_reqd_for_weapon()
bool is_demonic(unsigned char weapon_subtype)
{
    switch (weapon_subtype)
    {
    case WPN_DEMON_BLADE:
    case WPN_DEMON_WHIP:
    case WPN_DEMON_TRIDENT:
        return true;
    default:
        return false;
    }
}                               // end is_demonic()
bool launches_things( unsigned char weapon_subtype )
{
    switch (weapon_subtype)
    {
    case WPN_SLING:
    case WPN_BOW:
    case WPN_CROSSBOW:
    case WPN_HAND_CROSSBOW:
    case WPN_BLOWGUN:
        return (true);
    default:
        return (false);
    }
}                               // end launches_things()
unsigned char launched_by(unsigned char weapon_subtype)
{
    switch (weapon_subtype)
    {
    case WPN_BLOWGUN:
        return MI_NEEDLE;
    case WPN_SLING:
        return MI_STONE;
    case WPN_BOW:
        return MI_ARROW;
    case WPN_CROSSBOW:
        return MI_BOLT;
    case WPN_HAND_CROSSBOW:
        return MI_DART;
    default:
        return MI_EGGPLANT;     // lame debugging code :P {dlb}
    }
}                               // end launched_by()
// this function returns the skill that the weapon would use in melee
char weapon_skill(unsigned char wclass, unsigned char wtype)
{
    char skill2use = SK_FIGHTING;
    if (wclass == OBJ_STAVES
        && (wtype < STAFF_SMITING || wtype >= STAFF_AIR))
    {
        skill2use = SK_STAVES;
    }
    else if (wclass != OBJ_WEAPONS)
        skill2use = SK_FIGHTING;
    else
    {
        switch (wtype)
        {
        case WPN_CLUB:
        case WPN_MACE:
        case WPN_HAMMER:
        case WPN_ANCUS:
        case WPN_WHIP:
        case WPN_FLAIL:
        case WPN_MORNINGSTAR:
        case WPN_GIANT_CLUB:
        case WPN_GIANT_SPIKED_CLUB:
        case WPN_EVENINGSTAR:
        case WPN_DEMON_WHIP:
        case WPN_SPIKED_FLAIL:
        case WPN_GREAT_FLAIL:
        case WPN_GREAT_MACE:
        case WPN_BOW:
        case WPN_BLOWGUN:
        case WPN_CROSSBOW:
        case WPN_HAND_CROSSBOW:
            skill2use = SK_MACES_FLAILS;
            break;
        case WPN_KNIFE:
        case WPN_DAGGER:
        case WPN_SHORT_SWORD:
        case WPN_QUICK_BLADE:
        case WPN_SABRE:
            skill2use = SK_SHORT_BLADES;
            break;
        case WPN_FALCHION:
        case WPN_LONG_SWORD:
        case WPN_SCIMITAR:
        case WPN_KATANA:
        case WPN_DOUBLE_SWORD:
        case WPN_DEMON_BLADE:
        case WPN_GREAT_SWORD:
        case WPN_TRIPLE_SWORD:
            skill2use = SK_LONG_SWORDS;
            break;
        case WPN_HAND_AXE:
        case WPN_WAR_AXE:
        case WPN_BROAD_AXE:
        case WPN_BATTLEAXE:
        case WPN_EXECUTIONERS_AXE:
            skill2use = SK_AXES;
            break;
        case WPN_SPEAR:
        case WPN_HALBERD:
        case WPN_GLAIVE:
        case WPN_SCYTHE:
        case WPN_TRIDENT:
        case WPN_DEMON_TRIDENT:
            skill2use = SK_POLEARMS;
            break;
        case WPN_QUARTERSTAFF:
            skill2use = SK_STAVES;
            break;
        }
    }
    return (skill2use);
}                               // end weapon_skill()
/*
 **************************************************
 *                                                *
 *              END PUBLIC FUNCTIONS              *
 *                                                *
 **************************************************
*/

# Make file for Dungeon Crawl (solaris)
APPNAME = crawl
# this file contains a list of the libraries.
# it will make a variable called OBJECTS that contains all the libraries
include makefile.obj
CXX = g++
DELETE = rm -f
COPY = cp
GROUP = games
MOVE = mv
OS_TYPE = SOLARIS
CFLAGS = -Wall -Wwrite-strings -Wstrict-prototypes \
            -Wmissing-prototypes -Wmissing-declarations \
            -g -D$(OS_TYPE) $(EXTRA_FLAGS)
LDFLAGS = -static
MCHMOD = 2755
INSTALLDIR = /opt/local/newcrawl/bin
LIB = -lcurses
all:            $(APPNAME)
install:        $(APPNAME)
		#strip $(APPNAME)
		$(MOVE) ${INSTALLDIR}/${APPNAME} ${INSTALLDIR}/${APPNAME}.old
		$(COPY) $(APPNAME) ${INSTALLDIR}
		chgrp ${GROUP} ${INSTALLDIR}/${APPNAME}
		chmod ${MCHMOD} ${INSTALLDIR}/$(APPNAME)
clean:
		$(DELETE) *.o
distclean:
		$(DELETE) *.o 
		$(DELETE) bones.*
		$(DELETE) morgue.txt
		$(DELETE) scores 
		$(DELETE) $(APPNAME) 
		$(DELETE) *.sav
		$(DELETE) core
		$(DELETE) *.0*
		$(DELETE) *.lab
$(APPNAME):	$(OBJECTS)
		${CXX} ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(APPNAME) $(LIB)
debug:		$(OBJECTS)
		${CXX} ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(APPNAME) $(LIB)
profile:	$(OBJECTS)
		${CXX} -g -p ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(APPNAME) $(LIB)
.cc.o:
		${CXX} ${CFLAGS} -c $< ${INCLUDE}
.h.cc:
		touch $@
OBJECTS += libunix.o
#
# Modified for Crawl Reference by $Author$ on $Date$
#

# Make file for Dungeon Crawl (irix)
APPNAME = crawl
# this file contains a list of the libraries.
# it will make a variable called OBJECTS that contains all the libraries
include makefile.obj
CXX = CC
DELETE = rm -f
COPY = cp
OS_TYPE = LINUX
CFLAGS = -Wall -D$(OS_TYPE) $(EXTRA_FLAGS)
LDFLAGS = -L/usr/lib
MCHMOD = 711
INSTALLDIR = /usr/games
LIB = -lncurses
# Include for Linux
INCLUDES = -I/usr/include/ncurses
all:            $(APPNAME)
%.o:		%.cc
		@echo hello
		@${CXX} ${CFLAGS} -c $< ${INCLUDE}
install:        $(APPNAME)
		$(COPY) $(APPNAME) ${INSTALLDIR}
		chmod ${MCHMOD} ${INSTALLDIR}/$(APPNAME)
clean:
		$(DELETE) *.o
distclean:
		$(DELETE) *.o 
		$(DELETE) bones.*
		$(DELETE) morgue.txt
		$(DELETE) scores 
		$(DELETE) $(APPNAME) 
$(APPNAME):	$(OBJECTS)
		${CXX} ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(APPNAME) $(LIB)
		strip $(APPNAME)
		chmod ${MCHMOD} $(APPNAME)
debug:		$(OBJECTS)
		${CXX} ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(APPNAME) $(LIB)
profile:	$(OBJECTS)
		${CXX} -g -p ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(APPNAME) $(LIB)
.h.cc:
		touch $@

# -*- Makefile -*- for Dungeon Crawl (linux)
GAME = crawl
# this file contains a list of the libraries.
# it will make a variable called OBJECTS that contains all the libraries
include makefile.obj
CXX = g++
DELETE = rm -f
COPY = cp
OS_TYPE = LINUX
            -g -D$(OS_TYPE) $(EXTRA_FLAGS)
MCHMOD = 2755
LIB = -lncurses
# Include for Linux
INCLUDES = -I/usr/include/ncurses
all: $(GAME)
install: $(GAME)
	$(COPY) $(GAME) ${INSTALLDIR}
	chmod ${MCHMOD} ${INSTALLDIR}/$(GAME)
clean:
	$(DELETE) *.o
distclean:
	$(DELETE) *.o
	$(DELETE) bones.*
	$(DELETE) morgue.txt
	$(DELETE) scores
	$(DELETE) $(GAME)
	$(DELETE) *.sav
	$(DELETE) core
	$(DELETE) *.0*
	$(DELETE) *.lab
$(GAME): $(OBJECTS)
	${CXX} ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(GAME) $(LIB)
	chmod ${MCHMOD} $(GAME)
debug: $(OBJECTS)
	${CXX} ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(GAME) $(LIB)
profile:	$(OBJECTS)
	${CXX} -g -p ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(GAME) $(LIB)
.cc.o:
	${CXX} ${CFLAGS} -c $< ${INCLUDE}
.h.cc:
	touch $@
# [dshaligram] More common location than /opt/crawl/bin - this is from the
# Debian patch.
INSTALLDIR = /usr/games
CFLAGS = -Wall -Wwrite-strings -fsigned-char \
OBJECTS += libunix.o
#
# Modified for Crawl Reference by $Author$ on $Date$
#

# Makefile for Dungeon Crawl (OS/2 EMX port)
# 1998 (C) Alexey Guzeev, aga@russia.crosswinds.net
# EMX is covered by GNU GPL
# Dungeon Crawl is covered by Crawl GPL
# OS/2 is a trademark of IBM Corp.
# IBM  is a trademark of IBM Corp.
# :)
# 1. make some directory, like \crawl
# 2. make subdirectory for sources, \crawl\src
# 3. put crawl sources in \crawl\src directory
# 4. make directory \crawl\src current
# 5. execute command 'dmake -B -r -f makefile.emx install'
# 6. remove \crawl\src subdirectory with all contents
# 7. delete \crawl\scoretable.exe - I don't know what it does :)
# 8. run \crawl\crawl.exe & enjoy!
CC	= gcc
CFLAGS	= -Wall -O3 -MMD -Zmt -DUSE_EMX 
LIBS	= -lvideo -lbsd
AR	= ar
include makefile.obj
OBJ 	= $(OBJECTS)
all:            crawl.exe scoretable.exe
install:	..\crawl.exe ..\scoretable.exe
crawl.a: $(OBJS)
	$(AR) r crawl.a $(OBJS)
..\crawl.exe:	crawl.exe
		+copy crawl.exe ..
                emxbind -s ..\crawl.exe
..\scoretable.exe:	scoretable.exe
		+copy scoretable.exe ..
                emxbind -s ..\scoretable.exe
clean:
		+del *.o
crawl.exe:      crawl.a libemx.o
		$(CC) -o crawl.exe crawl.a libemx.o $(LIBS)
scoretable.exe: scoretab.o libemx.o
		$(CC) -o scoretable.exe scoretab.o libemx.o $(LIBS)
.cc.o:
		$(CC) $(CFLAGS) -c $*.cc

GAME = crawl
# this file contains a list of the libraries.
# it will make a variable called OBJECTS that contains all the libraries
include makefile.obj
CXX = g++
DELETE = rm -f
COPY = cp
OS_TYPE = BSD
CFLAGS = -Wall -D$(OS_TYPE) $(EXTRA_FLAGS)
LDFLAGS = -static -L/usr/lib
MCHMOD = 711
# INSTALLDIR = /usr/games
INSTALLDIR = /tmp/CRAWLTEST/testdev
LIB = -lncurses
INCLUDES = -I/usr/include/ncurses
all:            $(GAME)
install:        $(GAME)
		$(COPY) $(GAME) ${INSTALLDIR}
		chmod ${MCHMOD} ${INSTALLDIR}/$(GAME)
clean:
		$(DELETE) *.o
distclean:
		$(DELETE) *.o 
		$(DELETE) bones.*
		$(DELETE) morgue.txt
		$(DELETE) scores 
		$(DELETE) $(GAME)
		$(DELETE) *.sav
		$(DELETE) core
		$(DELETE) *.0*
		$(DELETE) *.lab
$(GAME): $(OBJECTS)
	${CXX} ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(GAME) $(LIB)
	strip $(GAME)
	chmod ${MCHMOD} $(GAME)
debug: $(OBJECTS)
	${CXX} ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(GAME) $(LIB)
profile:	$(OBJECTS)
	${CXX} -g -p ${LDFLAGS} $(INCLUDES) $(CFLAGS) $(OBJECTS) -o $(GAME) $(LIB)
.cc.o:
	${CXX} ${CFLAGS} -c $< ${INCLUDE}
.h.cc:
	touch $@
OBJECTS += libunix.o
#
# Modified for Crawl Reference by $Author$ on $Date$
#
# -*- Makefile -*- for Dungeon Crawl (BSD)

#
# Makefile for Borland C++ 5.5 free commandline tools
#
!include makefile.obj
GAME = ..\crawl.exe
all : $(GAME)
.PHONY : clean
.PHONY : debug
.PHONY : noopt
.PHONY : install
.PHONY : wizard
clean : 
	$(DEL) *.o
debug : 
noopt : 
install : 
wizard : 
#
# Borland C++ tools
#
CC     = bcc32
LINK   = ilink32
DEL    = del
# 
# windows defines,  including windows version to make sure code runs on
# all windows systems
#
WIN32DEFINES = WIN32CONSOLE;NEED_SPRINTF;WINVER=0x0400;_WIN32_WINNT=0x0400;__BCPLUSPLUS__
#
# Options
#
LINKOPTS    = -Tpe -ap -c -x /V4.0
CFLAGS      = -I. -D$(WIN32DEFINES) -4 -a -k- -Oc -OS -Oi -Ov -H- -P -c
NICEFLAGS   = -w-8004
DEBUGFLAGS  = -v -y
$(GAME) : $(OBJECTS) libw32c.o
	$(LINK) $(LINKOPTS) c0x32.obj $?, $(GAME),, import32.lib cw32.lib
.cc.o:
	$(CC) $(CFLAGS) $(NICEFLAGS) -o$*.o $< 

/*
 *  File:       libmac.h
 *  Summary:    Mac specific routines used by Crawl.
 *  Written by: Jesse Jones
 *
 *  Change History (most recent first): 
 *
 *    <2>     5/25/02     JDJ       Updated for Mach-O targets
 *    <1>     3/23/99     JDJ       Created
 */
 
#ifndef LIBMAC_H
#define LIBMAC_H
#if macintosh
#ifdef _BSD_SIZE_T_			// $$$ is there a better way to test for OS X?
	#define OSX	1
#else
	#define OS9	1
#endif
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#if OSX
	#include <unistd.h>
#endif
#define MAC_NUMBER_OF_LINES     30
// constants
const int _NORMALCURSOR = 1;
const int _NOCURSOR = 0;
// non-ANSI functions
int stricmp(const char* lhs, const char* rhs);
char* strlwr(char* str);
void itoa(int n, char* buffer, int radix);
#if !OSX
	inline void srandom(unsigned int seed)
	{
	    srand(seed);
	}
	int open(const char* path, int openFlags, int permissions);
	int open(const char* path, int openFlags, int permissions, int mysteryFlags);
	int close(int desc);
	int read(int desc, void *buffer, unsigned int bytes);
	int write(int desc, const void *buffer, unsigned int bytes);
	int unlink(const char* path);
#endif
// curses(?) functions
void clrscr();
void gotoxy(int x, int y);
void textcolor(int c);
void cprintf(const char* format,...);
void window(int x, int y, int lx, int ly);
int wherex();
int wherey();
void putch(char c);
int kbhit();
char getche();
int getch();
void getstr(char* buffer, int bufferSize);
void textbackground(int c);
void _setcursortype(int curstype);
// misc functions
void delay(int ms);
void init_mac();
void deinit_mac();
#endif // macintosh
#endif // LIBMAC_H

/*
 *  File:       libmac.cc
 *  Summary:    Mac specific routines used by Crawl.
 *  Written by: Jesse Jones (jesjones@mindspring.com)
//
//---------------------------------------------------------------
void itoa(int value, char* buffer, int radix)
{
    ASSERT(buffer != NULL);
    ASSERT(radix == 10 || radix == 2);
    if (radix == 10)
        sprintf(buffer, "%i", value);
    if (radix == 2)
    {                           /* int to "binary string" */
        unsigned int bitmask = 32768;
        int ctr = 0;
        int startflag = 0;
        while (bitmask)
        {
            if (value & bitmask)
            {
                startflag = 1;
                sprintf(buffer + ctr, "1");
            }
            else
            {
                if (startflag)
                    sprintf(buffer + ctr, "0");
            }
            bitmask = bitmask >> 1;
            if (startflag)
                ctr++;
        }
        if (!startflag)         /* Special case if value == 0 */
            sprintf((buffer + ctr++), "0");
        buffer[ctr] = (char) NULL;
    }
}
#if __MWERKS__
#pragma mark -
#endif
// ========================================================================
//	Curses(?) Functions
// ========================================================================
//---------------------------------------------------------------
//
// window
//
//---------------------------------------------------------------
void window(int x, int y, int lx, int ly)
{
    ASSERT(lx == kTermWidth);   // window size is hard-coded
    ASSERT(ly == kTermHeight);
    gotoxy(x, y);
}
//---------------------------------------------------------------
//
// clrscr
//
//---------------------------------------------------------------
void clrscr()
{
    ASSERT(sApp != NULL);
    sApp->Clear();
}
//---------------------------------------------------------------
//
// textcolor
//
//---------------------------------------------------------------
void textcolor(int c)
{
    ASSERT(c >= 0);
    ASSERT(c < 16);
    ASSERT(sApp != NULL);
    RGBColor color = ConvertColor(c);
    sApp->SetForeColor(color);
}
//---------------------------------------------------------------
//
// textbackground
//
//---------------------------------------------------------------
void textbackground(int c)
{
    ASSERT(c >= 0);
    ASSERT(c < 16);
    ASSERT(sApp != NULL);
    RGBColor color = ConvertColor(c);
    sApp->SetBackColor(color);
}
//---------------------------------------------------------------
//
// gotoxy
//
//---------------------------------------------------------------
void gotoxy(int x, int y)
{
    ASSERT(x >= 1);
    ASSERT(y >= 1);
    ASSERT(sApp != NULL);
    sApp->SetCursor(x - 1, y - 1);
}
//---------------------------------------------------------------
//
// wherex
//
//---------------------------------------------------------------
int wherex()
{
    ASSERT(sApp != NULL);
    Point pos = sApp->GetCursor();
    return pos.h + 1;
}
//---------------------------------------------------------------
//
// wherey
//
//---------------------------------------------------------------
int wherey()
{
    ASSERT(sApp != NULL);
    Point pos = sApp->GetCursor();
    return pos.v + 1;
}
//---------------------------------------------------------------
//
// putch
//
//---------------------------------------------------------------
void putch(char ch)
{
    ASSERT(sApp != NULL);
    char buffer[2];
    buffer[0] = ch;
    buffer[1] = '\0';
    sApp->SetChar(ch);
//  sApp->Print(buffer);
}
//---------------------------------------------------------------
//
// cprintf
//
//---------------------------------------------------------------
void cprintf(const char* format,...)
{
    ASSERT(sApp != NULL);
    char buffer[2048];
    va_list argp;
    va_start(argp, format);
    vsprintf(buffer, format, argp);
    va_end(argp);
    sApp->Print(buffer);
}
//---------------------------------------------------------------
//
// kbhit
//
//---------------------------------------------------------------
int kbhit()
{
    return sApp->PeekChar();
}
//---------------------------------------------------------------
//
// getche
//
//---------------------------------------------------------------
char getche()
{
    char ch = getch();
    if (ch != '\r')
        putch(ch);
    return ch;
}
//---------------------------------------------------------------
//
// getstr
//
//---------------------------------------------------------------
void getstr(char* buffer, int bufferSize)
{
    ASSERT(buffer != NULL);
    ASSERT(bufferSize > 1);
    int index = 0;
    while (index < bufferSize - 1)
    {
        char ch = getche();
        if (ch == '\r')
            break;
        else if (ch == '\b' && index > 0)
            --index;
        else if (isprint(ch))
            buffer[index++] = ch;
    }
    buffer[index] = '\0';
}
//---------------------------------------------------------------
//
// _setcursortype
//
//---------------------------------------------------------------
void _setcursortype(int curstype)
{
    ASSERT(curstype == _NORMALCURSOR || curstype == _NOCURSOR);
    ASSERT(sApp != NULL);
    sApp->ShowCursor(curstype == _NORMALCURSOR);
}
//---------------------------------------------------------------
//
// getch
//
//---------------------------------------------------------------
int getch()
{
    ASSERT(sApp != NULL);
    return sApp->GetChar();
}
#if __MWERKS__
#pragma mark -
#endif
// ========================================================================
//	Misc Functions
// ========================================================================
//---------------------------------------------------------------
//
// delay
//
//---------------------------------------------------------------
void delay(int ms)
{
    ASSERT(ms >= 0);
	usleep(1000*ms);
}
//---------------------------------------------------------------
//
// init_mac
//
//---------------------------------------------------------------
void init_mac()
{
    ASSERT(sApp == NULL);
	// Read in the color table
	sColors = GetCTable(256);
	if (sColors == NULL)
	{
		WarnUser("Couldn't load the colour table!");
		ExitToShell();
	}
	// Create the application object
	sApp = new CApplication;
}
//---------------------------------------------------------------
//
// deinit_mac
//
//---------------------------------------------------------------
void deinit_mac()
{
    delete sApp;
    sApp = NULL;
}
#endif // macintosh
// Converts an integer to a string (after libunix.cc).
 *
 *  Modified for Crawl Reference by $Author$ on $Date$

#ifndef LIBEMX_H
#define LIBEMX_H
#ifndef __LIBEMX_C__
#include <stdlib.h>
#include <conio.h>
#define itoa _itoa
#define _NORMALCURSOR 1
#define _NOCURSOR 0
void init_emx();
void deinit_emx();
void _setcursortype(int curstype);
void clrscr();
void gotoxy(int x, int y);
void textcolor(int c);
void cprintf (const char *format, ...);
void puttext(int x, int y, int lx, int ly, const char *buf);
void puttext(int x, int y, int lx, int ly, unsigned const char *buf);
void gettext(int x, int y, int lx, int ly, char *buf);
void gettext(int x, int y, int lx, int ly, unsigned char *buf);
void window(int x, int y, int lx, int ly);
int wherex();
int wherey();
void putch(char c);
int kbhit();
void delay(int ms);
void textbackground(int c);
#endif // __LIBEMX_C__
#endif

#include <stdio.h>
#include <stdarg.h>
#include <emx/syscalls.h>
#include <sys/video.h>
#include "libemx.h"
static int cursor_start = 0, cursor_end = 0;
static int gx = 0, gy = 0, gxx = 79, gyy = 24;
static char buf[4096];
void init_emx()
{
    v_init();
    v_getctype(&cursor_start, &cursor_end);
}
void deinit_emx()
{
    // nothing to do
}
void _setcursortype(int curstype)
{
    if ( curstype == _NOCURSOR )
      v_hidecursor();
    else
      v_ctype(cursor_start, cursor_end);
}
void clrscr()
{
    if ( (gx == 0) && (gy == 0) && (gxx == 79) && (gyy == 24) )
      {
        v_clear();
        v_gotoxy(0, 0);
      }
    else
      {
        for (int i = gy; i <= gyy; ++i)
          {
            v_gotoxy(gx, i);
            v_putn(' ', gxx - gx + 1);
          }
        v_gotoxy(gx, gy);
      }
}
void gotoxy(int x, int y)
{
    v_gotoxy(x - 1 + gx, y - 1 + gy);
}
void textcolor(int c)
{
    v_attrib(c);
}
static void cprintf_aux(const char *s)
{
    char *ptr = buf;
    while (*s)
    {
        if ( *s == '\n' )
          {
            *ptr = 0;
            v_puts(buf);
            int x, y;
            v_getxy(&x, &y);
            if ( y != 24 )
              v_gotoxy(gx, y + 1);
            else
              v_putc('\n');
            ptr = buf;
          }
        else if ( *s != '\r' )
          *ptr++ = *s;
        ++s;
    }
    *ptr = 0;
    v_puts(buf);
}
void cprintf(const char *format, ...)
{
   va_list argp;
   char buffer[4096]; // one could hope it's enough
   va_start( argp, format );
   vsprintf(buffer, format, argp);
   cprintf_aux(buffer);
   va_end(argp);
}
void puttext(int x, int y, int lx, int ly, unsigned const char *buf)
{
    puttext(x, y, lx, ly, (const char *) buf);
}
void puttext(int x, int y, int lx, int ly, const char *buf)
{
    int count = (lx - x + 1);
    for (int i = y - 1; i < ly; ++i)
      {
        v_putline(buf + 2 * count * i, x - 1, i, count);
      }
}
void gettext(int x, int y, int lx, int ly, unsigned char *buf)
{
    gettext(x, y, lx, ly, (char *) buf);
}
void gettext(int x, int y, int lx, int ly, char *buf)
{
    int count = (lx - x + 1);
    for (int i = y - 1; i < ly; ++i)
      {
        v_getline(buf + 2 * count * i, x - 1, i, count);
      }
}
void window(int x, int y, int lx, int ly)
{
    gx = x - 1;
    gy = y - 1;
    gxx = lx - 1;
    gyy = ly - 1;
}
int wherex()
{
    int x, y;
    v_getxy(&x, &y);
    return x + 1 - gx;
}
int wherey()
{
    int x, y;
    v_getxy(&x, &y);
    return y + 1 - gy;
}
void putch(char c)
{
    v_putc(c);
}
int kbhit()
{
    return 0;
}
void delay(int ms)
{
    __sleep2(ms);
}
void textbackground(int c)
{
    if ( c != 0 )
      {
        fprintf(stderr, "bad background=%d", c);
        exit(1);
      }
}

/*
 *  File:       MacString.h
 *  Summary:    Wrapper around an immutable CFString.
 *  Written by: Jesse Jones (jesjones@mindspring.com)
 *
 *  Change History (most recent first):
 *
 *      <1>     6/04/02     JDJ     Created
 */
#ifndef MAC_STRING_H
#define MAC_STRING_H
#if macintosh
#include <CoreFoundation/CFBase.h>
// ============================================================================
//	class MacString
//!		Wrapper around an immutable CFString.
// ============================================================================
class MacString {
//-----------------------------------
//	Initialization/Destruction
//
public:
						~MacString();
						MacString();
						
						MacString(const char* str);				
						MacString(const unsigned char* str);				
						/**< Uses default system encoding. */
						MacString(CFStringRef str);
						/**< Bumps the ref count. */
						
						MacString(CFMutableStringRef str);
						/**< Makes a copy. */
	explicit			MacString(int value);
						MacString(const MacString& str);				
			MacString& 	operator=(const MacString& rhs);
//-----------------------------------
//	API
//
public:
	// ----- Size -----
			size_t 		length() const;
			size_t		size() const						{return this->length();}
			bool		empty() const						{return this->length() == 0;}
	// ----- Access -----
			void 		CopyTo(unsigned char* buffer, CFIndex bytes);
						
						operator CFStringRef() const		{return mString;}
//-----------------------------------
//	Member Data
//
private:
	CFStringRef	mString;
};
#endif // macintosh
#endif // MAC_STRING_H

/*
 *  File:       MacString.cc
 *  Summary:    Wrapper around an immutable CFString.
 *  Written by: Jesse Jones (jesjones@mindspring.com)
 *
 *  Change History (most recent first):
 *
 *      <1>     6/04/02     JDJ     Created
 */
#include "AppHdr.h"
#include "MacString.h"
#if macintosh
#include <CoreFoundation/CFString.h>
#include "debug.h"
// ========================================================================
//	Internal Functions
// ========================================================================
//---------------------------------------------------------------
//
// ThrowIf
//
//---------------------------------------------------------------
static void ThrowIf(bool predicate, const std::string& text)
{
	if (predicate)
		throw std::runtime_error(text);
}
#if __MWERKS__
#pragma mark -
#endif
// ============================================================================
//	class MacString
// ============================================================================	
//---------------------------------------------------------------
//
// MacString::~MacString
//
//---------------------------------------------------------------
MacString::~MacString()
{
	CFRelease(mString);
}
//---------------------------------------------------------------
//
// MacString::MacString ()
//
//---------------------------------------------------------------
MacString::MacString()
{	
	mString = CFStringCreateWithCharacters(kCFAllocatorSystemDefault, NULL, 0);
	ThrowIf(mString == NULL, "Couldn't create the CFString");
}
//---------------------------------------------------------------
//
// MacString::MacString (unsigned char*)
//
//---------------------------------------------------------------
MacString::MacString(const unsigned char* str)
{
	ASSERT(str != NULL);
	
	CFStringEncoding encoding = CFStringGetSystemEncoding();
	mString = CFStringCreateWithPascalString(kCFAllocatorSystemDefault, str, encoding);
	ThrowIf(mString == NULL, "Couldn't create the CFString");
}
//---------------------------------------------------------------
//
// MacString::MacString (char*)
//
//---------------------------------------------------------------
MacString::MacString(const char* str)
{
	ASSERT(str != NULL);
	
	CFStringEncoding encoding = CFStringGetSystemEncoding();
	mString = CFStringCreateWithCString(kCFAllocatorSystemDefault, str, encoding);
	ThrowIf(mString == NULL, "Couldn't create the CFString");
}
//---------------------------------------------------------------
//
// MacString::MacString (CFStringRef)
//
//---------------------------------------------------------------
MacString::MacString(CFStringRef str)
{
	ASSERT(str != NULL);
	
	mString = str;
	CFRetain(mString);
}
//---------------------------------------------------------------
//
// MacString::MacString (CFMutableStringRef)
//
//---------------------------------------------------------------
MacString::MacString(CFMutableStringRef str)
{
	ASSERT(str != NULL);
	
	mString = CFStringCreateCopy(kCFAllocatorSystemDefault, str);	
	ThrowIf(mString == NULL, "Couldn't create the CFString");
}
//---------------------------------------------------------------
//
// MacString::MacString (int)
//
//---------------------------------------------------------------
MacString::MacString(int value)
{
	char buffer[32];
	sprintf(buffer, "%d", value);
	
	CFStringEncoding encoding = CFStringGetSystemEncoding();
	mString = CFStringCreateWithCString(kCFAllocatorSystemDefault, buffer, encoding);
	ThrowIf(mString == NULL, "Couldn't create the CFString");
}
//---------------------------------------------------------------
//
// MacString::MacString (MacString)
//
//---------------------------------------------------------------
MacString::MacString(const MacString& str)
{	
	mString = str.mString;			// immutable so we can refcount
	CFRetain(mString);
}
				
//---------------------------------------------------------------
//
// MacString::operator= (MacString)
//
//---------------------------------------------------------------
MacString& MacString::operator=(const MacString& rhs)
{
	if (this != &rhs) 
	{
		CFRelease(mString);
		mString = rhs.mString;		// immutable so we can refcount
		CFRetain(mString);
	}
	
	return *this;
}
//---------------------------------------------------------------
//
// MacString::length
//
//---------------------------------------------------------------
size_t MacString::length() const
{
	size_t len = (size_t) CFStringGetLength(mString);
	
	return len;
}
//---------------------------------------------------------------
//
// MacString::CopyTo
//
//---------------------------------------------------------------
void MacString::CopyTo(unsigned char* buffer, CFIndex bytes)
{
	ASSERT(buffer != NULL || bytes == 0);
	
	bool converted = CFStringGetPascalString(mString, buffer, bytes, CFStringGetSystemEncoding());
	ThrowIf(!converted, "Couldn't convert the CFString into a Pascal string");	
}
#endif // macintosh

 *
 *  Modified for Crawl Reference by $Author$ on $Date$

void init_char_table(char_set_type set);
void init_feature_table( void );

int get_number_of_cols(void);

void noisy( int loudness, int nois_x, int nois_y );

bool noisy( int loudness, int nois_x, int nois_y, const char *msg = NULL );

void show_map( FixedVector<int, 2>& spec_place );

void show_map( FixedVector<int, 2>& spec_place, bool travel_mode );

void set_envmap_char( int x, int y, unsigned char chr );
void set_envmap_detected_item(int x, int y, bool detected = true);
void set_envmap_detected_mons(int x, int y, bool detected = true);
bool is_envmap_detected_item(int x, int y);
bool is_envmap_detected_mons(int x, int y);
void set_terrain_mapped( int x, int y );
void set_terrain_seen( int x, int y );
bool is_terrain_known( int x, int y );
bool is_terrain_seen( int x, int y );
void clear_feature_overrides();
void add_feature_override(const std::string &text);
void clear_cset_overrides();
void add_cset_override(char_set_type set, const std::string &overrides);
bool see_grid( int grx, int gry );
std::string screenshot(bool fullscreen = false);
unsigned char get_sightmap_char(int feature);
unsigned char get_magicmap_char(int feature);
void viewwindow(bool draw_it, bool do_updates);
bool find_ray( int sourcex, int sourcey, int targetx, int targety,
               bool allow_fallback, ray_def& ray );
#if defined(WIN32CONSOLE) || defined(DOS)
unsigned short dos_brand( unsigned short colour,
                          unsigned brand = CHATTR_REVERSE);

#endif

#include "command.h"

#include "delay.h"
#include "direct.h"
#include "initfile.h"

#include "itemprop.h"

#include "misc.h"

// These are hidden from the rest of the world... use the functions
// below to get information about the map grid.
#define MAP_MAGIC_MAPPED_FLAG   0x0100
#define MAP_SEEN_FLAG           0x0200
#define MAP_CHANGED_FLAG        0x0400
#define MAP_DETECTED_MONSTER    0x0800
#define MAP_DETECTED_ITEM       0x1000

#define MAP_CHARACTER_MASK      0x00ff
struct feature_def
{
    unsigned short      symbol;          // symbol used for seen terrain
    unsigned short      magic_symbol;    // symbol used for magic-mapped terrain
    unsigned short      colour;          // normal in LoS colour
    unsigned short      map_colour;      // colour when out of LoS on display
    unsigned short      seen_colour;     // map_colour when is_terrain_seen()
    bool                notable;         // gets noted when seen
    bool                seen_effect;     // requires special handling when seen
};
struct feature_override
{
    dungeon_feature_type    feat;
    feature_def             override;
};
static FixedVector< struct feature_def, NUM_FEATURES >  Feature;
static std::vector<feature_override> Feature_Overrides;

typedef char screen_buffer_t;

// DOS functions like gettext() and puttext() can only
// work with arrays of characters, not shorts.
typedef unsigned char screen_buffer_t;

unsigned char your_sign;        // accessed as extern in transfor.cc and acr.cc
unsigned char your_colour;      // accessed as extern in transfor.cc and acr.cc

FixedArray < unsigned int, 20, 19 > Show_Backup;

FixedArray < unsigned int, 20, 19 > show_backup;

extern FixedVector<char, 10>  Visible_Statue;        // defined in acr.cc

extern void (*viewwindow) (char, bool);
unsigned char (*mapch) (unsigned char);
unsigned char (*mapch2) (unsigned char);
unsigned char mapchar(unsigned char ldfk);
unsigned char mapchar2(unsigned char ldfk);
unsigned char mapchar3(unsigned char ldfk);
unsigned char mapchar4(unsigned char ldfk);

static int display_glyph(int env_glyph);
static int item_env_glyph(const item_def &item);

static int get_item_dngn_code(const item_def &item);
static void set_show_backup( int ex, int ey );
// Applies EC_ colour substitutions and brands.
static unsigned fix_colour(unsigned raw_colour);

#elif MAC
    return (MAC_NUMBER_OF_LINES);

int get_number_of_cols(void)
{
#ifdef UNIX
    return (get_number_of_cols_from_curses());
#else
    return (80);
#endif
}

//---------------------------------------------------------------
//
// get_ibm_symbol
//
// Returns the DOS character code and color for everything drawn
// with the IBM graphics option.
//
//---------------------------------------------------------------
static void get_ibm_symbol(unsigned int object, unsigned short *ch,
                           unsigned short *color)

unsigned get_envmap_char(int x, int y)

    ASSERT(color != NULL);
    ASSERT(ch != NULL);

    return static_cast<unsigned char>(
            env.map[x - 1][y - 1] & MAP_CHARACTER_MASK);
}

    switch (object)
    {
    case DNGN_UNSEEN:
        *ch = 0;
        break;

void set_envmap_detected_item(int x, int y, bool detected)
{
    if (detected)
        env.map[x - 1][y - 1] |= MAP_DETECTED_ITEM;
    else
        env.map[x - 1][y - 1] &= ~MAP_DETECTED_ITEM;
}

    case DNGN_ROCK_WALL:
    case DNGN_PERMAROCK_WALL:
        *color = env.rock_colour;
        *ch = 177;
        break;                  // remember earth elementals

bool is_envmap_detected_item(int x, int y)
{
    return (env.map[x - 1][y - 1] & MAP_DETECTED_ITEM);
}

    // stone in the realm of Zot is coloured the same as rock
    case DNGN_STONE_WALL:
        *color = (player_in_branch( BRANCH_HALL_OF_ZOT ) ? env.rock_colour
                                                         : LIGHTGREY);
        *ch = 177;
        break;

void set_envmap_detected_mons(int x, int y, bool detected)
{
    if (detected)
        env.map[x - 1][y - 1] |= MAP_DETECTED_MONSTER;
    else
        env.map[x - 1][y - 1] &= ~MAP_DETECTED_MONSTER;
}

    case DNGN_CLOSED_DOOR:
        *ch = 254;
        break;

bool is_envmap_detected_mons(int x, int y)
{
    return (env.map[x - 1][y - 1] & MAP_DETECTED_MONSTER);
}

    case DNGN_METAL_WALL:
        *ch = 177;
        *color = CYAN;
        break;

void set_envmap_char( int x, int y, unsigned char chr )
{
    env.map[x - 1][y - 1] &= (~MAP_CHARACTER_MASK);       // clear old first
    env.map[x - 1][y - 1] |= chr;
}

    case DNGN_SECRET_DOOR:
        *ch = 177;
        *color = env.rock_colour;
        break;

bool is_terrain_known( int x, int y )
{
    return (env.map[x - 1][y - 1] & (MAP_MAGIC_MAPPED_FLAG | MAP_SEEN_FLAG));
}

    case DNGN_GREEN_CRYSTAL_WALL:
        *ch = 177;
        *color = GREEN;
        break;

bool is_terrain_seen( int x, int y )
{
    return (env.map[x - 1][y - 1] & MAP_SEEN_FLAG);
}

    case DNGN_ORCISH_IDOL:
        *ch = '8';
        *color = DARKGREY;
        break;

bool is_terrain_changed( int x, int y )
{
    return (env.map[x - 1][y - 1] & MAP_CHANGED_FLAG);
}

    case DNGN_WAX_WALL:
        *ch = 177;
        *color = YELLOW;
        break;                  // wax wall
        /* Anything added here must also be added to the PLAIN_TERMINAL
           viewwindow2 below */

// used to mark dug out areas, unset when terrain is seen or mapped again.
void set_terrain_changed( int x, int y )
{
    env.map[x - 1][y - 1] |= MAP_CHANGED_FLAG;
}

    case DNGN_SILVER_STATUE:
        *ch = '8';
        *color = WHITE;
        Visible_Statue[ STATUE_SILVER ] = 1;
        break;

void set_terrain_mapped( int x, int y )
{
    env.map[x - 1][y - 1] &= (~MAP_CHANGED_FLAG);
    env.map[x - 1][y - 1] |= MAP_MAGIC_MAPPED_FLAG;
}

    case DNGN_GRANITE_STATUE:
        *ch = '8';
        *color = LIGHTGREY;
        break;

void set_terrain_seen( int x, int y )
{
    env.map[x - 1][y - 1] &= (~MAP_CHANGED_FLAG);
    env.map[x - 1][y - 1] |= MAP_SEEN_FLAG;
}

    case DNGN_ORANGE_CRYSTAL_STATUE:
        *ch = '8';
        *color = LIGHTRED;
        Visible_Statue[ STATUE_ORANGE_CRYSTAL ] = 1;
        break;

void clear_envmap_grid( int x, int y )
{
    env.map[x - 1][y - 1] = 0;
}

    case DNGN_LAVA:
        *ch = 247;
        *color = RED;
        break;
    case DNGN_DEEP_WATER:
        *ch = 247;          // this wavy thing also used for water elemental
        *color = BLUE;
        break;
    case DNGN_SHALLOW_WATER:
        *ch = 247;          // this wavy thing also used for water elemental
        *color = CYAN;
        break;
    case DNGN_FLOOR:
        *color = env.floor_colour;
        *ch = 249;
        break;
    case DNGN_ENTER_HELL:
        *ch = 239;
        *color = RED;
        seen_other_thing(object);
        break;
    case DNGN_OPEN_DOOR:
        *ch = 39;
        break;
    case DNGN_BRANCH_STAIRS:
        *ch = 240;
        *color = BROWN;
        break;
    case DNGN_TRAP_MECHANICAL:
        *color = LIGHTCYAN;
        *ch = 94;
        break;
    case DNGN_TRAP_MAGICAL:
        *color = MAGENTA;
        *ch = 94;
        break;
    case DNGN_TRAP_III:
        *color = LIGHTGREY;
        *ch = 94;
        break;

void clear_envmap( void )
{
    for (int i = 0; i < GXM; i++)
    {
        for (int j = 0; j < GYM; j++)
        {
            env.map[i][j] = 0;
        }
    }
}

    case DNGN_UNDISCOVERED_TRAP:
        *ch = 249;
        *color = env.floor_colour;
        break;
    case DNGN_ENTER_SHOP:
        *ch = 239;
        *color = YELLOW;
        seen_other_thing(object);
        break;
    // if I change anything above here, must also change magic mapping!
    case DNGN_ENTER_LABYRINTH:
        *ch = 239;
        *color = LIGHTGREY;
        seen_other_thing(object);
        break;
    // not sure why we have "odd" here, but "ladders" are special in
    // that they all lead to the first staircase of the next level
    // (and returning from there will take you somewhere different)
    // ... that's why they're brown... it's a warning -- bwr
    case DNGN_ROCK_STAIRS_DOWN:
        *color = BROWN;         // ladder    // odd {dlb}
    case DNGN_STONE_STAIRS_DOWN_I:
    case DNGN_STONE_STAIRS_DOWN_II:
    case DNGN_STONE_STAIRS_DOWN_III:
        *ch = '>';
        break;
    case DNGN_ROCK_STAIRS_UP:
        *color = BROWN;         // ladder    // odd {dlb}
    case DNGN_STONE_STAIRS_UP_I:
    case DNGN_STONE_STAIRS_UP_II:
    case DNGN_STONE_STAIRS_UP_III:
        *ch = '<';
        break;
    case DNGN_ENTER_DIS:
        *color = CYAN;
        *ch = 239;
        break;
    case DNGN_ENTER_GEHENNA:
        *color = RED;
        *ch = 239;
        break;
    case DNGN_ENTER_COCYTUS:
        *color = LIGHTCYAN;
        *ch = 239;
        break;
    case DNGN_ENTER_TARTARUS:
        *color = DARKGREY;
        *ch = 239;
        break;
    case DNGN_ENTER_ABYSS:
        *color = random2(16);
        *ch = 239;
        seen_other_thing(object);
        break;
    case DNGN_EXIT_ABYSS:
        *color = random2(16);
        *ch = 239;
        break;
    case DNGN_STONE_ARCH:
        *color = LIGHTGREY;
        *ch = 239;
        break;
    case DNGN_ENTER_PANDEMONIUM:
        *color = LIGHTBLUE;
        *ch = 239;
        seen_other_thing(object);
        break;
    case DNGN_EXIT_PANDEMONIUM:
        *color = LIGHTBLUE;
        *ch = 239;
        break;
    case DNGN_TRANSIT_PANDEMONIUM:
        *color = LIGHTGREEN;
        *ch = 239;
        break;
    case DNGN_ENTER_ORCISH_MINES:
    case DNGN_ENTER_HIVE:
    case DNGN_ENTER_LAIR:
    case DNGN_ENTER_SLIME_PITS:
    case DNGN_ENTER_VAULTS:
    case DNGN_ENTER_CRYPT:
    case DNGN_ENTER_HALL_OF_BLADES:
    case DNGN_ENTER_TEMPLE:
    case DNGN_ENTER_SNAKE_PIT:
    case DNGN_ENTER_ELVEN_HALLS:
    case DNGN_ENTER_TOMB:
    case DNGN_ENTER_SWAMP:
    case 123:
    case 124:
    case 125:
    case 126:
        *color = YELLOW;
        *ch = '>';
        seen_staircase(object);
        break;
    case DNGN_ENTER_ZOT:
        *color = MAGENTA;
        *ch = 239;
        seen_staircase(object);
        break;
    case DNGN_RETURN_FROM_ORCISH_MINES:
    case DNGN_RETURN_FROM_HIVE:
    case DNGN_RETURN_FROM_LAIR:
    case DNGN_RETURN_FROM_SLIME_PITS:
    case DNGN_RETURN_FROM_VAULTS:
    case DNGN_RETURN_FROM_CRYPT:
    case DNGN_RETURN_FROM_HALL_OF_BLADES:
    case DNGN_RETURN_FROM_TEMPLE:
    case DNGN_RETURN_FROM_SNAKE_PIT:
    case DNGN_RETURN_FROM_ELVEN_HALLS:
    case DNGN_RETURN_FROM_TOMB:
    case DNGN_RETURN_FROM_SWAMP:
    case 143:
    case 144:
    case 145:
    case 146:
        *color = YELLOW;
        *ch = '<';
        break;
    case DNGN_RETURN_FROM_ZOT:
        *color = MAGENTA;
        *ch = 239;
        break;
    case DNGN_ALTAR_ZIN:
        *color = WHITE;
        *ch = 220;
        seen_altar(GOD_ZIN);
        break;
    case DNGN_ALTAR_SHINING_ONE:
        *color = YELLOW;
        *ch = 220;
        seen_altar(GOD_SHINING_ONE);
        break;
    case DNGN_ALTAR_KIKUBAAQUDGHA:
        *color = DARKGREY;
        *ch = 220;
        seen_altar(GOD_KIKUBAAQUDGHA);
        break;
    case DNGN_ALTAR_YREDELEMNUL:
        *color = ((one_chance_in(3)) ? RED : DARKGREY);
        *ch = 220;
        seen_altar(GOD_YREDELEMNUL);
        break;
    case DNGN_ALTAR_XOM:
        *color = random_colour();
        *ch = 220;
        seen_altar(GOD_XOM);
        break;
    case DNGN_ALTAR_VEHUMET:
        *color = LIGHTBLUE;
        if (one_chance_in(3))
            *color = LIGHTMAGENTA;
        if (one_chance_in(3))
            *color = LIGHTRED;
        *ch = 220;
        seen_altar(GOD_VEHUMET);
        break;
    case DNGN_ALTAR_OKAWARU:
        *color = CYAN;
        *ch = 220;
        seen_altar(GOD_OKAWARU);
        break;
    case DNGN_ALTAR_MAKHLEB:
        *color = RED;
        if (one_chance_in(3))
            *color = LIGHTRED;
        if (one_chance_in(3))
            *color = YELLOW;
        *ch = 220;
        seen_altar(GOD_MAKHLEB);
        break;
    case DNGN_ALTAR_SIF_MUNA:
        *color = BLUE;
        *ch = 220;
        seen_altar(GOD_SIF_MUNA);
        break;
    case DNGN_ALTAR_TROG:
        *color = RED;
        *ch = 220;
        seen_altar(GOD_TROG);
        break;
    case DNGN_ALTAR_NEMELEX_XOBEH:
        *color = LIGHTMAGENTA;
        *ch = 220;
        seen_altar(GOD_NEMELEX_XOBEH);
        break;
    case DNGN_ALTAR_ELYVILON:
        *color = LIGHTGREY;
        *ch = 220;
        seen_altar(GOD_ELYVILON);
        break;
    case DNGN_BLUE_FOUNTAIN:
        *color = BLUE;
        *ch = 159;
        break;
    case DNGN_SPARKLING_FOUNTAIN:
        *color = LIGHTBLUE;
        *ch = 159;
        break;
    case DNGN_DRY_FOUNTAIN_I:
    case DNGN_DRY_FOUNTAIN_II:
    case DNGN_PERMADRY_FOUNTAIN:
        *color = LIGHTGREY;
        *ch = 159;
        break;
    case 256:
        *ch = '0';
        break;
    case 257:
        *color = CYAN;
        *ch = '~';
        break;                  /* Invis creature walking through water */
    case 258:
        *ch = ')';
        break;                  // weapon )
    case 259:
        *ch = '[';
        break;                  // armour [
    case 260:
        *ch = '/';
        break;                  // wands, etc.
    case 261:
        *ch = '%';
        break;                  // food
    case 262:
        *ch = '+';
        break;                  // books +
    case 263:
        *ch = '?';
        break;                  // scroll ?
    case 264:
        *ch = '=';
        break;                  // ring = etc
    case 265:
        *ch = '!';
        break;                  // potions !
    case 266:
        *ch = '(';
        break;                  // stones
    case 267:
        *ch = '+';
        break;                  // book +
    case 268:
        *ch = '%';
        break;                  // corpses part 1
    case 269:
        *ch = '\\';
        break;                  // magical staves
    case 270:
        *ch = '}';
        break;                  // gems
    case 271:
        *ch = '%';
        break;                  // don't know ?
    case 272:
        *ch = '$';
        *color = YELLOW;
        break;                  // $ gold
    case 273:
        *ch = '"';
        break;                  // amulet

#if defined(WIN32CONSOLE) || defined(DOS) || defined(DOS_TERM)
static unsigned colflag2brand(int colflag)
{
    switch (colflag)
    {
    case COLFLAG_ITEM_HEAP:
        return (Options.heap_brand);
    case COLFLAG_FRIENDLY_MONSTER:
        return (Options.friend_brand);
    case COLFLAG_WILLSTAB:
        return (Options.stab_brand);
    case COLFLAG_MAYSTAB:
        return (Options.may_stab_brand);

        *ch = ((object >= 297) ? mons_char(object - 297) : object);
        break;

        return (CHATTR_NORMAL);

}                               // end get_ibm_symbol()

}
#endif

//---------------------------------------------------------------
//
// viewwindow2
//
// Draws the main window using the extended IBM character set.
//
// This function should not interfer with the game condition,
// unless do_updates is set (ie.  stealth checks for visible
// monsters).
//
//---------------------------------------------------------------
void viewwindow2(char draw_it, bool do_updates)

static unsigned fix_colour(unsigned raw_colour)

    const long BUFFER_SIZE = 1550;
#ifdef DOS_TERM
    // DOS functions like gettext() and puttext() can only
    // work with arrays of characters, not shorts.
    FixedVector < unsigned char, BUFFER_SIZE > buffy;   //[800]; //392];
#else
    FixedVector < unsigned short, BUFFER_SIZE > buffy;   //[800]; //392];

    // This order is important - is_element_colour() doesn't want to see the
    // munged colours returned by dos_brand, so it should always be done 
    // before applying DOS brands.
#if defined(WIN32CONSOLE) || defined(DOS) || defined(DOS_TERM)
    const int colflags = raw_colour & 0xFF00;

    unsigned short ch, color;

    // Evaluate any elemental colours to guarantee vanilla colour is returned
    if (is_element_colour( raw_colour ))
        raw_colour = element_colour( raw_colour );

    losight(env.show, grd, you.x_pos, you.y_pos);
    int count_x, count_y;
    for (count_x = 0; count_x < 18; count_x++)

#if defined(WIN32CONSOLE) || defined(DOS) || defined(DOS_TERM)
    if (colflags)

        for (count_y = 0; count_y < 18; count_y++)
        {
            env.show_col[count_x][count_y] = LIGHTGREY;
            show_backup[count_x][count_y] = 0;
        }

        unsigned brand = colflag2brand(colflags);
        raw_colour = dos_brand(raw_colour & 0xFF, brand);

    item();
    cloud_grid();
    monster_grid(do_updates);
    int bufcount = 0;
    if (draw_it == 1)
    {
        _setcursortype(_NOCURSOR);
        for (count_y = you.y_pos - 8; count_y < you.y_pos + 9; count_y++)
        {
            bufcount += 16;
            for (count_x = you.x_pos - 8; count_x < you.x_pos + 9; count_x++)
            {
                // may be overriden by the code below
                color = env.show_col[ count_x - you.x_pos + 9 ]
                                    [ count_y - you.y_pos + 9 ];
                unsigned int object = env.show[ count_x - you.x_pos + 9 ]
                                              [ count_y - you.y_pos + 9 ];
                get_ibm_symbol(object, &ch, &color);
                if (count_x == you.x_pos && count_y == you.y_pos)
                {
                    ch = your_sign;
                    if (player_is_swimming())
                    {
                        color = (grd[you.x_pos][you.y_pos] == DNGN_DEEP_WATER)
                                    ? BLUE : CYAN;
                    }
                    else
                    {
                        color = your_colour;
                    }
                }
                ASSERT(bufcount + 1 < BUFFER_SIZE);
                buffy[bufcount] = ch;
                buffy[bufcount + 1] = color;
                bufcount += 2;
            }
            bufcount += 16;
        }
        if (you.level_type != LEVEL_LABYRINTH && you.level_type != LEVEL_ABYSS)
        {
            bufcount = 0;

#endif

            for (count_y = 0; count_y < 17; count_y++)
            {
                bufcount += 16;

#ifndef USE_COLOUR_OPTS
    // Strip COLFLAGs for systems that can't do anything meaningful with them.
    raw_colour &= 0xFF;
#endif

                for (count_x = 0; count_x < 17; count_x++)
                {
                    ASSERT(bufcount < BUFFER_SIZE);

    return (raw_colour);
}

                    int mapx = count_x + you.x_pos - 9;
                    int mapy = count_y + you.y_pos - 9;
                    if (buffy[bufcount] != 0 && mapx >= 0 && mapx + 1 < GXM
                            && mapy >= 0 && mapy + 1 < GYM)
                    {
                        unsigned short bch = buffy[bufcount];
                        if (mgrd[mapx + 1][mapy + 1] != NON_MONSTER) {
                            const monsters &m = menv[mgrd[mapx + 1][mapy + 1]];
                            if (!mons_is_mimic(m.type)
                                    && mons_char(m.type) == bch)
                            {
                                bch |= mons_colour(m.type) << 12;
                            }
                        }
                        env.map[mapx][mapy] = bch;
                    }

static void get_symbol( unsigned int object, unsigned short *ch, 
                        unsigned short *colour )
{
    ASSERT( ch != NULL );
    ASSERT( colour != NULL );

                    if (Options.clean_map == 1
                        && show_backup[count_x + 1][count_y + 1] != 0)
                    {
                        get_ibm_symbol(show_backup[count_x + 1][count_y + 1],
                                       &ch, &color);
                        if (mapx >= 0 && mapx < GXM 
                                && mapy >= 0 && mapy < GYM)
                            env.map[ count_x + you.x_pos - 9 ]
                               [ count_y + you.y_pos - 9 ] = ch;
                    }
                    bufcount += 2;
                }
                bufcount += 16;
            }
        }

    if (object < NUM_FEATURES)
    {
        *ch = Feature[object].symbol;    

        bufcount = 0;
        for (count_y = 0; count_y < 17; count_y++)
        {
            for (count_x = 0; count_x < 33; count_x++)
            {
                if (count_x + you.x_pos - 17 < 3
                    || count_y + you.y_pos - 9 < 3
                    || count_x + you.x_pos - 14 > 77
                    || count_y + you.y_pos - 9 > 67)
                {
                    ASSERT(bufcount < BUFFER_SIZE);
                    buffy[bufcount] = 0;
                    bufcount++;
                    buffy[bufcount] = 0;
                    bufcount++;
                    continue;
                }
                if (count_x >= 8 && count_x <= 24 && count_y >= 0
                    && count_y <= 16 && buffy[bufcount] != 0)
                {
                    bufcount += 2;
                    continue;
                }
                ASSERT(bufcount + 1 < BUFFER_SIZE);
                buffy[bufcount] = (unsigned char) 
                                  env.map[ count_x + you.x_pos - 17 ]
                                         [ count_y + you.y_pos - 9 ];
                buffy[bufcount + 1] = DARKGREY;
                if (Options.colour_map)
                {
                    if (env.map[ count_x + you.x_pos - 17 ]
                               [ count_y + you.y_pos - 9 ] != 0)
                    {
                        buffy[bufcount + 1] 
                                = colour_code_map( count_x + you.x_pos - 17, 
                                                   count_y + you.y_pos - 9,
                                                   Options.item_colour );
                    }
                }
                bufcount += 2;
            }
        }
        if (you.berserker)
        {
            for (count_x = 1; count_x < 1400; count_x += 2)
            {
                if (buffy[count_x] != DARKGREY)
                    buffy[count_x] = RED;
            }
        }
        if (show_green != BLACK)
        {
            for (count_x = 1; count_x < 1400; count_x += 2)
            {
                if (buffy[count_x] != DARKGREY)
                    buffy[count_x] = show_green;
            }
            show_green = BLACK;

        // Don't clobber with BLACK, because the colour should be already set.
        if (Feature[object].colour != BLACK)
            *colour = Feature[object].colour;

            if (you.special_wield == SPWLD_SHADOW)
                show_green = DARKGREY;
        }

        // Note anything we see that's notable
        if (Feature[object].notable)
            seen_notable_thing( object );
    }
    else
    {
        ASSERT( object >= DNGN_START_OF_MONSTERS );
        *ch = mons_char( object - DNGN_START_OF_MONSTERS );
    }

#ifdef DOS_TERM
        puttext(2, 1, 34, 17, buffy.buffer());
#endif

    *colour = fix_colour(*colour);
}

#ifdef PLAIN_TERM
        gotoxy(2, 1);
        bufcount = 0;

unsigned char get_sightmap_char( int feature )
{
    if (feature < NUM_FEATURES)
        return (Feature[feature].symbol);

        // following lines are purely optional.
        // if used,  players will 'jump' move.
        // Resting will be a LOT faster too.
        if (you.running == 0 || (you.running < 0 && Options.travel_delay > -1))
        {
            for (count_x = 0; count_x < 1120; count_x += 2)
            {                   // 1056
                ch = buffy[count_x];
                color = buffy[count_x + 1];
//                ASSERT(color < 16);
                ASSERT(ch < 255);

    return (0);
}

                textcolor(color);
                putch(ch);

unsigned char get_magicmap_char( int feature )
{
    if (feature < NUM_FEATURES)
        return (Feature[feature].magic_symbol);

                if (count_x % 66 == 64 && count_x > 0)
                    gotoxy(2, wherey() + 1);
            }
            // remember to comment out the line below if you comment out jump move.
        }
        _setcursortype(_NORMALCURSOR);
#endif
    }
}                               // end viewwindow2()

    return (0);
}

    short dist = point_distance[x + 1]
                               [y + 1];
    return dist > 0                     ?   BLUE :
           dist == PD_EXCLUDED          ?   LIGHTMAGENTA :
           dist == PD_EXCLUDED_RADIUS   ?   RED :
           dist < 0                     ?   CYAN :
                                            DARKGREY;

    short dist = point_distance[x + 1][y + 1];
    return dist > 0?                    Options.tc_reachable        :
           dist == PD_EXCLUDED?         Options.tc_excluded         :
           dist == PD_EXCLUDED_RADIUS?  Options.tc_exclude_circle   :
           dist < 0?                    Options.tc_dangerous        :
                                        Options.tc_disconnected;

        // Special casery for shadows. Note this must be matched by the fix
        // to libw32c.cc (the unpatched libw32c.cc does not draw spaces of any 
        // colour).

        // Special casery for shadows.

static unsigned short dos_brand( unsigned short colour,
                                 unsigned brand = CHATTR_REVERSE ) 

unsigned short dos_brand( unsigned short colour,
                          unsigned brand) 

// FIXME: Rework this function to use the new terrain known/seen checks
// These are still env.map coordinates, NOT grid coordinates!

    const unsigned short map_flags = env.map[x][y] & ENVF_FLAGS;

    const unsigned short map_flags = env.map[x][y];

    char tc = travel_colour? get_travel_colour(x, y) : DARKGREY;

    unsigned tc = travel_colour? 
                        get_travel_colour(x, y)
                      : DARKGREY;

    if (map_flags & ENVF_DETECT_ITEM)

    if (map_flags & MAP_DETECTED_ITEM)

    if (map_flags & ENVF_DETECT_MONS) {

    if (map_flags & MAP_DETECTED_MONSTER)
    {

        return (tc);

        return fix_colour(tc);

    unsigned char ecol = ENVF_COLOR(map_flags);
    if (ecol) {
        unsigned rmc = Options.remembered_monster_colour & 0xFFFF;
        if (rmc == 0xFFFF)   // Use real colour
            tc = ecol;
        else if (rmc == 0)   // Don't colour
            ;
        else
            tc = rmc;
    }
    

        return tc;

        return fix_colour(tc);

    if (map_value != mapch2( grid_value )) {

    if (map_value != get_sightmap_char(grid_value))
    {

                && map_value == display_glyph(item_env_glyph(mitm[item])))

                && map_value == 
                        get_sightmap_char(get_item_dngn_code(mitm[item])))

            screen_buffer_t ic = mitm[item].colour;

            unsigned ic = mitm[item].colour;

#if defined(WIN32CONSOLE) || defined(DOS) || defined(DOS_TERM)
            if (mitm[item].link != NON_ITEM 
                    && Options.heap_brand != CHATTR_NORMAL)
            {
                ic = dos_brand(ic, Options.heap_brand);
            }
#elif defined(USE_COLOUR_OPTS)

            {

            }
#endif

            return ic == tc? WHITE : ic;

            return fix_colour( ic == tc? WHITE : ic );

        return tc;

    switch (grid_value)
    {
    case DNGN_TRAP_MECHANICAL:
        return (LIGHTCYAN);
    case DNGN_TRAP_MAGICAL:
    case DNGN_TRAP_III:
        return (MAGENTA);
    case DNGN_ENTER_SHOP:
        return (YELLOW);
    case DNGN_ENTER_DIS:
        return (CYAN);
    case DNGN_ENTER_HELL:
    case DNGN_ENTER_GEHENNA:
        return (RED);
    case DNGN_ENTER_COCYTUS:
        return (LIGHTCYAN);
    case DNGN_ENTER_ABYSS:
        return random2(16);     // so it can be black - is this right? {dlb}
    case DNGN_ENTER_LABYRINTH:
    case DNGN_STONE_ARCH:
        return (LIGHTGREY);

    case DNGN_ENTER_PANDEMONIUM:
        return (LIGHTBLUE);

    int feature_colour = DARKGREY;
    feature_colour = 
        is_terrain_seen(x + 1, y + 1)? Feature[grid_value].seen_colour 
                                     : Feature[grid_value].map_colour;

    case DNGN_EXIT_PANDEMONIUM:
        // Exit pandemonium gates won't show up on the map as light blue
        // unless the character has the "gate to pandemonium" demonspawn 
        // mutation.  This is so that the player can't quickly use a 
        // crystal ball to find their way out.  -- bwr
        return (you.mutation[MUT_PANDEMONIUM] ? LIGHTBLUE : LIGHTGREEN);

    if (feature_colour != DARKGREY)
        tc = feature_colour;

    case DNGN_TRANSIT_PANDEMONIUM:
        return (LIGHTGREEN);
    case DNGN_ENTER_ZOT:
    case DNGN_RETURN_FROM_ZOT:
        return (MAGENTA);
    case DNGN_STONE_STAIRS_DOWN_I:
    case DNGN_STONE_STAIRS_DOWN_II:
    case DNGN_STONE_STAIRS_DOWN_III:
    case DNGN_ROCK_STAIRS_DOWN:
        return (RED);
    case DNGN_STONE_STAIRS_UP_I:
    case DNGN_STONE_STAIRS_UP_II:
    case DNGN_STONE_STAIRS_UP_III:
    case DNGN_ROCK_STAIRS_UP:
        return (GREEN);
    case DNGN_ENTER_ORCISH_MINES:
    case DNGN_ENTER_HIVE:
    case DNGN_ENTER_LAIR:
    case DNGN_ENTER_SLIME_PITS:
    case DNGN_ENTER_VAULTS:
    case DNGN_ENTER_CRYPT:
    case DNGN_ENTER_HALL_OF_BLADES:
    case DNGN_ENTER_TEMPLE:
    case DNGN_ENTER_SNAKE_PIT:
    case DNGN_ENTER_ELVEN_HALLS:
    case DNGN_ENTER_TOMB:
    case DNGN_ENTER_SWAMP:
    case 123:
    case 124:
    case 125:
    case 126:
        return (LIGHTRED);
    case DNGN_RETURN_FROM_ORCISH_MINES:
    case DNGN_RETURN_FROM_HIVE:
    case DNGN_RETURN_FROM_LAIR:
    case DNGN_RETURN_FROM_SLIME_PITS:
    case DNGN_RETURN_FROM_VAULTS:
    case DNGN_RETURN_FROM_CRYPT:
    case DNGN_RETURN_FROM_HALL_OF_BLADES:
    case DNGN_RETURN_FROM_TEMPLE:
    case DNGN_RETURN_FROM_SNAKE_PIT:
    case DNGN_RETURN_FROM_ELVEN_HALLS:
    case DNGN_RETURN_FROM_TOMB:
    case DNGN_RETURN_FROM_SWAMP:
    case 143:
    case 144:
    case 145:
    case 146:
        return (LIGHTBLUE);
    default:
        break;
    }
    return tc;

    return fix_colour(tc);

    for (int y = 0; y < GYM - 1; ++y)

    for (int y = Y_BOUND_1; y <= Y_BOUND_2; ++y)

        for (int x = 0; x < GXM - 1; ++x)

        for (int x = X_BOUND_1; x <= X_BOUND_2; ++x)

            unsigned short envc = env.map[x][y];
            if (!envc)

            // Don't expose new dug out areas:
            // Note: assumptions are being made here about how 
            // terrain can change (eg it used to be solid, and
            // thus monster/item free).
            if (is_terrain_changed(x, y))

            bool unmapped = (envc & ENVF_DETECTED) != 0;
            // Discard flags at this point.
            envc = (unsigned char) envc;
            const unsigned char &grdc = grd[x + 1][y + 1];
            if (envc == mapch(grdc) || envc == mapch2(grdc))

            unsigned short envc = env.map[x][y] & MAP_CHARACTER_MASK;
            if (!envc)

            int item = igrd[x + 1][y + 1];

            const int item = igrd[x + 1][y + 1];

                    && envc == display_glyph(item_env_glyph(mitm[item])))

                    && envc == 
                        get_sightmap_char(get_item_dngn_code(mitm[item])))

            env.map[x][y] = unmapped? 0 : mapch2(grdc);

            set_envmap_char(x, y,
                    is_terrain_seen(x, y)? get_sightmap_char(grd[x][y]) :
                    is_terrain_known(x, y)? get_magicmap_char(grd[x][y]) :
                                            0);
            set_envmap_detected_mons(x, y, false);

                if (you.turn_is_over == 1

                if (you.turn_is_over

            const int ex = monster->x - you.x_pos + 9;
            const int ey = monster->y - you.y_pos + 9;

                    show_backup[ monster->x - you.x_pos + 9 ]
                               [ monster->y - you.y_pos + 9]
                       = env.show[ monster->x - you.x_pos + 9 ]
                                 [ monster->y - you.y_pos + 9 ];
                    env.show[monster->x - you.x_pos + 9]
                            [monster->y - you.y_pos + 9] = 257;

                    set_show_backup(ex, ey);
                    env.show[ex][ey] = DNGN_INVIS_EXPOSED;
                    env.show_col[ex][ey] = BLUE; 

                     && !mons_flag( monster->type, M_NO_EXP_GAIN ))

                     && !mons_class_flag( monster->type, M_NO_EXP_GAIN ))

                interrupt_activity( AI_SEE_MONSTER );
                if (you.running != 0
#ifdef CLUA_BINDINGS
                    && clua.callbooleanfn(true, "ch_stop_run",
                                          "M", monster)
#endif
                        )
                {
                    // Friendly monsters, mimics, or harmless monsters 
                    // don't disturb the player's running/resting.
                    // 
                    // Doing it this way causes players in run mode 2
                    // to move one square, and in mode 1 to stop.  This
                    // means that the character will run one square if
                    // a monster is in sight... we automatically jump
                    // to zero if we're resting.  -- bwr
                    if (you.run_x == 0 && you.run_y == 0)
                        stop_running();
                    else if (you.running > 1)
                        you.running--;
                    else
                        stop_running();
                }

                interrupt_activity( AI_SEE_MONSTER, monster );
                seen_monster( monster );

            {
                show_backup[monster->x - you.x_pos + 9]
                           [monster->y - you.y_pos + 9]
                       = env.show[monster->x - you.x_pos + 9]
                                 [monster->y - you.y_pos + 9];
            }

                set_show_backup(ex, ey);

            env.show[monster->x - you.x_pos + 9]
                    [monster->y - you.y_pos + 9] = monster->type + 297;

            env.show[ex][ey] = monster->type + DNGN_START_OF_MONSTERS;
            env.show_col[ex][ey] = monster->colour;

            env.show_col[monster->x - you.x_pos + 9]
                        [monster->y - you.y_pos + 9]
                = ((mcolour[monster->type] == BLACK)
                        ? monster->number : mcolour[monster->type]);
#ifdef USE_COLOUR_OPTS

                env.show_col[monster->x - you.x_pos + 9]
                            [monster->y - you.y_pos + 9]
                    |= COLFLAG_FRIENDLY_MONSTER;

                env.show_col[ex][ey] |= COLFLAG_FRIENDLY_MONSTER;

                    && !mons_is_mimic(monster->type)
                    && monster->type != MONS_OKLOB_PLANT
                    && mons_is_stabbable(monster))

                    && mons_looks_stabbable(monster))

                env.show_col[monster->x - you.x_pos + 9]
                            [monster->y - you.y_pos + 9]
                    |= COLFLAG_WILLSTAB;

                env.show_col[ex][ey] |= COLFLAG_WILLSTAB;

                    && !mons_is_mimic(monster->type)
                    && monster->type != MONS_OKLOB_PLANT
                    && mons_maybe_stabbable(monster))

                    && mons_looks_distracted(monster))

                env.show_col[monster->x - you.x_pos + 9]
                            [monster->y - you.y_pos + 9]
                    |= COLFLAG_MAYSTAB;
            }
#elif defined(WIN32CONSOLE) || defined(DOS)
            if (Options.friend_brand != CHATTR_NORMAL 
                    && mons_friendly(monster))
            {
                // We munge the colours right here for DOS and Windows, because
                // we know exactly how the colours will be handled, and we don't
                // want to change both DOS and Windows port code to handle
                // friend branding.
                unsigned short &colour =
                        env.show_col[monster->x - you.x_pos + 9]
                                    [monster->y - you.y_pos + 9];
                colour = dos_brand(colour, Options.friend_brand);

                env.show_col[ex][ey] |= COLFLAG_MAYSTAB;

            
            if (Options.stab_brand != CHATTR_NORMAL
                    && !mons_is_mimic(monster->type)
                    && monster->type != MONS_OKLOB_PLANT
                    && mons_is_stabbable(monster))
            {
                unsigned short &colour =
                        env.show_col[monster->x - you.x_pos + 9]
                                    [monster->y - you.y_pos + 9];
                colour = dos_brand(colour, Options.stab_brand);
            }
            else if (Options.may_stab_brand != CHATTR_NORMAL
                    && !mons_is_mimic(monster->type)
                    && monster->type != MONS_OKLOB_PLANT
                    && mons_maybe_stabbable(monster))
            {
                unsigned short &colour =
                        env.show_col[monster->x - you.x_pos + 9]
                                    [monster->y - you.y_pos + 9];
                colour = dos_brand(colour, Options.may_stab_brand);
            }
#endif

    const int mon_holy = mons_holiness( monster->type );

    const int mon_holy = mons_holiness(monster);

    // still actively on guard for the player,  even if they can't see

    // still actively on guard for the player, even if they can't see

    // after a while,  removing this bonus.

    // after a while, removing this bonus.

static int display_glyph(int env_glyph)

static void set_show_backup( int ex, int ey )

    unsigned short ch, color;
    if (viewwindow == viewwindow2)
        get_ibm_symbol(env_glyph, &ch, &color);
    else
        get_non_ibm_symbol(env_glyph, &ch, &color);
    return ch;

    // Must avoid double setting it.  
    // We want the base terrain/item, not the cloud or monster that replaced it.
    if (!Show_Backup[ex][ey])
        Show_Backup[ex][ey] = env.show[ex][ey];

static int item_env_glyph(const item_def &item)

static int get_item_dngn_code(const item_def &item)

        return 256;
        // need + 6 because show is 0 - 12, not -6 - +6

        return (DNGN_ITEM_ORB);

        return (DNGN_ITEM_WEAPON);

        return 258;

        return (DNGN_ITEM_MISSILE);

        return 259;

        return (DNGN_ITEM_ARMOUR);

        return 260;

        return (DNGN_ITEM_WAND);

        return 261;
    case OBJ_UNKNOWN_I:
        return 262;

        return (DNGN_ITEM_FOOD);

        return 263;

        return (DNGN_ITEM_SCROLL);

        return item.sub_type >= AMU_RAGE? 273 : 264;

        return (jewellery_is_amulet(item)? DNGN_ITEM_AMULET : DNGN_ITEM_RING);

        return 265;
    case OBJ_UNKNOWN_II:
        return 266;

        return (DNGN_ITEM_POTION);

        return 267;

        return (DNGN_ITEM_BOOK);

        return 269;

        return (DNGN_ITEM_STAVE);

        return 270;

        return (DNGN_ITEM_MISCELLANY);

        return 271;

        return (DNGN_ITEM_CORPSE);

        return 272;