//#define TIMING_INFO
#ifdef TIMING_INFO
#include <time.h>
#include "message.h"

// TIMING info
static int ncalls[6] = { 0,0,0,0,0,0 };
static double runavg[6] = { 0.0,0.0,0.0,0.0,0.0,0.0 };
static int oob[6] = { 0,0,0,0,0,0 };
static int dlen[6] = { 0,0,0,0,0,0 };
static LARGE_INTEGER t1, t2;
static void addcall(int i, LARGE_INTEGER &tm1, LARGE_INTEGER &tm2)

void writeChar(char c)

    double d = tm2.QuadPart - tm1.QuadPart;

    bool noop = true;
    PCHAR_INFO pci;

    runavg[i] = (runavg[i] * ncalls[i] + d) / (ncalls[i] + 1);
    ncalls[i] ++;

    // check for CR: noop
    if (c == 0x0D)
        return;

    // oob
    if (ncalls[i] > 10)

    // check for newline
    if (c == 0x0A)

        if (d > 1.4*runavg[i])
            oob[i] ++;
    }
}
#define CLOCKIN     {QueryPerformanceCounter(&t1);}
#define CLOCKOUT(x) {QueryPerformanceCounter(&t2); \
                     addcall((x), t1, t2);}
static char *descrip[] =
{
    "bflush:WriteConsoleOutput",
    "_setCursorType:SetConsoleCursorInfo",
    "gotoxy:SetConsoleCursorPosition",
    "textcolor:SetConsoleTextAttribute",
    "cprintf:WriteConsole",
    "getch:ReadConsoleInput"
};
void print_timings(void)
{
    int i;
    char s[100];

        // must flush current buffer
        bFlush();

    LARGE_INTEGER cps;
    QueryPerformanceFrequency(&cps);

        // reposition
        gotoxy(1, cy+2);

    sprintf(s, "Avg (#/oob), CpS = %.1lf", cps.QuadPart);
    mpr(s);
    for(i=0; i<3; i++)
    {
        int dl = 0;
        if (ncalls[i] > 0)
            dl = dlen[i] / ncalls[i];
        sprintf(s, "%-40s %.1f us (%d/%d), avg dlen = %d", descrip[i],
            (1000000.0 * runavg[i]) / cps.QuadPart, ncalls[i], oob[i], dl);
        mpr(s);

        return;

}

#else

    int tc = WIN32COLOR(current_color);
    pci = &screen[SCREENINDEX(cx,cy)];

#define CLOCKIN
#define CLOCKOUT(x)
void print_timings()
{ ; }
#endif // TIMING INFO

    // is this a no-op?
    if (pci->Char.AsciiChar != c)
        noop = false;
    else if (pci->Attributes != tc)
        noop = false;

void writeChar(char c)
{
   bool noop = true;
   PCHAR_INFO pci;
   // check for CR: noop
   if (c == 0x0D)
      return;
   // check for newline
   if (c == 0x0A)
   {
      // must flush current buffer
      bFlush();
      // reposition
      gotoxy(1, cy+2);
      return;
   }
   int tc = WIN32COLOR(current_color);
   pci = &screen[SCREENINDEX(cx,cy)];
   // is this a no-op?
   if (pci->Char.AsciiChar != c)
      noop = false;
   else if (pci->Attributes != tc)
      noop = false;
   if (!noop)
   {
      // write the info and update the dirty area
      pci->Char.AsciiChar = c;
      pci->Attributes = tc;

    if (!noop)
    {
        // write the info and update the dirty area
        pci->Char.AsciiChar = c;
        pci->Attributes = tc;

      if (chy < 0)
         chsx = cx;
      chy = cy;
      chex = cx;

        if (chy < 0)
            chsx = cx;
        chy = cy;
        chex = cx;

      // if we're not buffering, flush
      if (!buffering)
         bFlush();
   }

        // if we're not buffering, flush
        if (!buffering)
            bFlush();
    }

   // update x position
   cx += 1;
   if (cx >= screensize.X) cx = screensize.X;

    // update x position
    cx += 1;
    if (cx >= screensize.X) cx = screensize.X;

   COORD source;
   SMALL_RECT target;

    COORD source;
    SMALL_RECT target;

   // see if we have a dirty area
   if (chy < 0)
      return;

    // see if we have a dirty area
    if (chy < 0)
        return;

   // set up call
   source.X = chsx;
   source.Y = chy;

    // set up call
    source.X = chsx;
    source.Y = chy;

   target.Left = chsx;
   target.Top = chy;
   target.Right = chex;
   target.Bottom = chy;

    target.Left = chsx;
    target.Top = chy;
    target.Right = chex;
    target.Bottom = chy;

   CLOCKIN
   WriteConsoleOutput(outbuf, screen, screensize, source, &target);
   CLOCKOUT(0)

    WriteConsoleOutput(outbuf, screen, screensize, source, &target);

   chy = -1;

    chy = -1;

   // if cursor is not NOCURSOR, update screen
   if (cursor_is_enabled)
   {
      COORD xy;
      xy.X = cx;
      xy.Y = cy;
      CLOCKIN
      SetConsoleCursorPosition(outbuf, xy);
      CLOCKOUT(2)
   }

    // if cursor is not NOCURSOR, update screen
    if (cursor_is_enabled)
    {
        COORD xy;
        xy.X = cx;
        xy.Y = cy;
        SetConsoleCursorPosition(outbuf, xy);
    }

   DWORD inmodes, outmodes;
   if (value == TRUE)
   {
      inmodes = ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT;
      outmodes = ENABLE_PROCESSED_OUTPUT;
   }
   else
   {
      inmodes = 0;
      outmodes = 0;
   }

    DWORD inmodes, outmodes;
    if (value == TRUE)
    {
        inmodes = ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT
                     | ENABLE_PROCESSED_INPUT
                     | ENABLE_MOUSE_INPUT
                     | ENABLE_WINDOW_INPUT;
        outmodes = ENABLE_PROCESSED_OUTPUT;
    }
    else
    {
        inmodes = ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT;
        outmodes = 0;
    }

   if ( SetConsoleMode( inbuf, inmodes ) == 0)
   {
      fputs("Error initialising console input mode.", stderr);
      exit(0);
   }

    if ( SetConsoleMode( inbuf, inmodes ) == 0)
    {
        fputs("Error initialising console input mode.", stderr);
        exit(0);
    }

   if ( SetConsoleMode( outbuf, outmodes ) == 0)
   {
      fputs("Error initialising console output mode.", stderr);
      exit(0);
   }

    if ( SetConsoleMode( outbuf, outmodes ) == 0)
    {
        fputs("Error initialising console output mode.", stderr);
        exit(0);
    }

   // now flush it
   FlushConsoleInputBuffer( inbuf );

    // now flush it
    FlushConsoleInputBuffer( inbuf );

static void set_w32_screen_size()
{
    CONSOLE_SCREEN_BUFFER_INFO cinf;
    if (::GetConsoleScreenBufferInfo(outbuf, &cinf))
    {
        screensize.X = cinf.srWindow.Right - cinf.srWindow.Left + 1;
        screensize.Y = cinf.srWindow.Bottom - cinf.srWindow.Top + 1;
    }
    else
    {
        screensize.X = 80;
        screensize.Y = 25;
    }
    if (screen)
    {
        delete [] screen;
        screen = NULL;
    }
   
    screen = new CHAR_INFO[screensize.X * screensize.Y];
    COORD topleft;
    SMALL_RECT used;
    topleft.X = topleft.Y = 0;
    ::ReadConsoleOutput(outbuf, screen, screensize, topleft, &used);
}
static void w32_handle_resize_event()
{
    if (crawl_state.waiting_for_command)
        handle_terminal_resize(true);
    else
        crawl_state.terminal_resized = true;
}
static void w32_check_screen_resize()
{
    CONSOLE_SCREEN_BUFFER_INFO cinf;
    if (::GetConsoleScreenBufferInfo(outbuf, &cinf))
    {
        if (screensize.X != cinf.srWindow.Right - cinf.srWindow.Left + 1
            || screensize.Y != cinf.srWindow.Bottom - cinf.srWindow.Top + 1)
        {
            w32_handle_resize_event();
        }
    }
}

static void w32_term_resizer()
{
    set_w32_screen_size();
    crawl_view.init_geometry();
}

   inbuf = GetStdHandle( STD_INPUT_HANDLE );
   outbuf = GetStdHandle( STD_OUTPUT_HANDLE );

    inbuf = GetStdHandle( STD_INPUT_HANDLE );
    outbuf = GetStdHandle( STD_OUTPUT_HANDLE );

   if (inbuf == INVALID_HANDLE_VALUE || outbuf == INVALID_HANDLE_VALUE)
   {
      fputs("Could not initialise libw32c console support.", stderr);
      exit(0);
   }

    if (inbuf == INVALID_HANDLE_VALUE || outbuf == INVALID_HANDLE_VALUE)
    {
        fputs("Could not initialise libw32c console support.", stderr);
        exit(0);
    }

   GetConsoleTitle( oldTitle, 78 );
   SetConsoleTitle( CRAWL " " VERSION );

    GetConsoleTitle( oldTitle, 78 );
    SetConsoleTitle( CRAWL " " VERSION );

   install_sighandlers();

    install_sighandlers();

   init_colors(oldTitle);
   // by default, set string input to false:  use char-input only
   setStringInput( false );
   if (SetConsoleMode( outbuf, 0 ) == 0)
   {
      fputs("Error initialising console output mode.", stderr);
      exit(0);
   }

   // set up screen size

    init_colors(oldTitle);

   CONSOLE_SCREEN_BUFFER_INFO cinf;
   if (::GetConsoleScreenBufferInfo(outbuf, &cinf))
   {
       screensize.X = cinf.srWindow.Right - cinf.srWindow.Left + 1;
       screensize.Y = cinf.srWindow.Bottom - cinf.srWindow.Top + 1;
   }
   else
   {
       screensize.X = 80;
       screensize.Y = 25;
   }

    // by default, set string input to false:  use char-input only
    setStringInput( false );

   screen = new CHAR_INFO[screensize.X * screensize.Y];

    // set up screen size
    set_w32_screen_size();

   // initialise text color
   textcolor(DARKGREY);

    // initialise text color
    textcolor(DARKGREY);

   // initialise cursor to NONE.
   _setcursortype_internal(false);

    // initialise cursor to NONE.
    _setcursortype_internal(false);

   // buffering defaults to ON -- very important!
   setBuffering(true);

    // buffering defaults to ON -- very important!
    setBuffering(true);

   //DEBUG
   //foo = fopen("debug.txt", "w");

    crawl_state.terminal_resize_handler = w32_term_resizer;
    crawl_state.terminal_resize_check   = w32_check_screen_resize;
   
    // JWM, 06/12/2004: Code page setting, as XP does not use ANSI 437 by
    // default.
    InputCP = GetConsoleCP();
    OutputCP = GetConsoleOutputCP();

   // JWM, 06/12/2004: Code page setting, as XP does not use ANSI 437 by
   // default.
   InputCP = GetConsoleCP();
   OutputCP = GetConsoleOutputCP();
   // DS: Don't kill Crawl if we can't set the codepage. Windows 95/98/ME don't
   // have support for setting the input and output codepage.  I'm also not
   // convinced we need to set the input codepage at all.
   if (InputCP != PREFERRED_CODEPAGE)
      SetConsoleCP(PREFERRED_CODEPAGE);

    // Don't kill Crawl if we can't set the codepage. Windows 95/98/ME
    // don't have support for setting the input and output codepage.
    // I'm also not convinced we need to set the input codepage at all.
    if (InputCP != PREFERRED_CODEPAGE)
        SetConsoleCP(PREFERRED_CODEPAGE);

   if (OutputCP != PREFERRED_CODEPAGE)
      SetConsoleOutputCP(PREFERRED_CODEPAGE);

    if (OutputCP != PREFERRED_CODEPAGE)
        SetConsoleOutputCP(PREFERRED_CODEPAGE);

   // don't do anything if we were never initted
   if (inbuf == NULL || outbuf == NULL)
      return;

    // don't do anything if we were never initted
    if (inbuf == NULL || outbuf == NULL)
        return;

   // JWM, 06/12/2004: Code page stuff.  If it was the preferred code page, it 
   // doesn't need restoring.  Shouldn't be an error and too bad if there is.
   if (InputCP && InputCP != PREFERRED_CODEPAGE)
      SetConsoleCP(InputCP);

    // JWM, 06/12/2004: Code page stuff.  If it was the preferred code page, it 
    // doesn't need restoring.  Shouldn't be an error and too bad if there is.
    if (InputCP && InputCP != PREFERRED_CODEPAGE)
        SetConsoleCP(InputCP);

   if (OutputCP && OutputCP != PREFERRED_CODEPAGE)
      SetConsoleOutputCP(OutputCP);
    
   // restore console attributes for normal function
   setStringInput(true);

    if (OutputCP && OutputCP != PREFERRED_CODEPAGE)
        SetConsoleOutputCP(OutputCP);
    // restore console attributes for normal function
    setStringInput(true);

   // set cursor and normal textcolor
   _setcursortype_internal(true);
   textcolor(DARKGREY);

    // set cursor and normal textcolor
    _setcursortype_internal(true);
    textcolor(DARKGREY);

   delete [] screen;
   screen = NULL;

    delete [] screen;
    screen = NULL;

   // finally, restore title
   SetConsoleTitle( oldTitle );

    // finally, restore title
    SetConsoleTitle( oldTitle );

   CONSOLE_CURSOR_INFO cci;

    CONSOLE_CURSOR_INFO cci;

   if (curstype == cursor_is_enabled)
       return;

    if (curstype == cursor_is_enabled)
        return;

   cci.dwSize = 5;
   cci.bVisible = curstype? TRUE : FALSE;
   cursor_is_enabled = curstype;
   CLOCKIN
   SetConsoleCursorInfo( outbuf, &cci );
   CLOCKOUT(1)

    cci.dwSize = 5;
    cci.bVisible = curstype? TRUE : FALSE;
    cursor_is_enabled = curstype;
    SetConsoleCursorInfo( outbuf, &cci );

   // now, if we just changed from NOCURSOR to CURSOR,
   // actually move screen cursor
   if (cursor_is_enabled)
       gotoxy(cx+1, cy+1);

    // now, if we just changed from NOCURSOR to CURSOR,
    // actually move screen cursor
    if (cursor_is_enabled)
        gotoxy(cx+1, cy+1);

   int x,y;
   COORD source;
   SMALL_RECT target;

    int x,y;
    COORD source;
    SMALL_RECT target;

   PCHAR_INFO pci = screen;

    PCHAR_INFO pci = screen;

   for(x = 0; x < screensize.X; x++)
   {
      for(y = 0; y < screensize.Y; y++)
      {
         pci->Char.AsciiChar = ' ';
         pci->Attributes = 0;
         pci++;
      }
   }

    for(x = 0; x < screensize.X; x++)
    {
        for(y = 0; y < screensize.Y; y++)
        {
            pci->Char.AsciiChar = ' ';
            pci->Attributes = 0;
            pci++;
        }
    }

   source.X = 0;
   source.Y = 0;
   target.Left = 0;
   target.Top = 0;
   target.Right = screensize.X - 1;
   target.Bottom = screensize.Y - 1;

    source.X = 0;
    source.Y = 0;
    target.Left = 0;
    target.Top = 0;
    target.Right = screensize.X - 1;
    target.Bottom = screensize.Y - 1;

   WriteConsoleOutput(outbuf, screen, screensize, source, &target);

    WriteConsoleOutput(outbuf, screen, screensize, source, &target);

   // reset cursor to 1,1 for convenience
   gotoxy(1,1);

    // reset cursor to 1,1 for convenience
    gotoxy(1,1);

   // always flush on goto
   bFlush();

    // always flush on goto
    bFlush();

   // bounds check
   if (x < 1)
      x = 1;
   if (x > screensize.X)
      x = screensize.X;
   if (y < 1)
      y = 1;
   if (y > screensize.Y)
      y = screensize.Y;

    // bounds check
    if (x < 1)
        x = 1;
    if (x > screensize.X)
        x = screensize.X;
    if (y < 1)
        y = 1;
    if (y > screensize.Y)
        y = screensize.Y;

   // change current cursor
   cx = x - 1;
   cy = y - 1;

    // change current cursor
    cx = x - 1;
    cy = y - 1;

   // if cursor is not NOCURSOR, update screen
   if (cursor_is_enabled)
   {
      COORD xy;
      xy.X = cx;
      xy.Y = cy;
      CLOCKIN
      if (SetConsoleCursorPosition(outbuf, xy) == 0)
         fputs("SetConsoleCursorPosition() failed!", stderr);
      CLOCKOUT(2)
   }

    // if cursor is not NOCURSOR, update screen
    if (cursor_is_enabled)
    {
        COORD xy;
        xy.X = cx;
        xy.Y = cy;
        if (SetConsoleCursorPosition(outbuf, xy) == 0)
            fputs("SetConsoleCursorPosition() failed!", stderr);
    }

   // change current color used to stamp chars
   current_color = c;

    // change current color used to stamp chars
    current_color = c;

   PCHAR_INFO pci = screen + SCREENINDEX(crawl_view.msgp.x - 1,
                                         crawl_view.msgp.y - 1);
   for (int x = 0; x < screensize.X; x++)
   {
      for (int y = 0; y < crawl_view.msgsz.y; y++)
      {
         pci->Char.AsciiChar = ' ';
         pci->Attributes = 0;
         pci++;
      }
   }

    PCHAR_INFO pci = screen + SCREENINDEX(crawl_view.msgp.x - 1,
                                          crawl_view.msgp.y - 1);
    for (int x = 0; x < screensize.X; x++)
    {
        for (int y = 0; y < crawl_view.msgsz.y; y++)
        {
            pci->Char.AsciiChar = ' ';
            pci->Attributes = 0;
            pci++;
        }
    }

   COORD source;
   SMALL_RECT target;

    COORD source;
    SMALL_RECT target;

   source.X = crawl_view.msgp.x - 1;
   source.Y = crawl_view.msgp.y - 1;
   target.Left = crawl_view.msgp.x - 1;
   target.Top = crawl_view.msgp.y - 1;
   target.Right = screensize.X - 1;
   target.Bottom = screensize.Y - 1;

    source.X = crawl_view.msgp.x - 1;
    source.Y = crawl_view.msgp.y - 1;
    target.Left = crawl_view.msgp.x - 1;
    target.Top = crawl_view.msgp.y - 1;
    target.Right = screensize.X - 1;
    target.Bottom = screensize.Y - 1;

   WriteConsoleOutput(outbuf, screen, screensize, source, &target);

    WriteConsoleOutput(outbuf, screen, screensize, source, &target);

   // early out -- not initted yet
   if (outbuf == NULL)
   {
      printf(s);
      return;
   }

    // early out -- not initted yet
    if (outbuf == NULL)
    {
        printf(s);
        return;
    }

   // turn buffering ON (temporarily)
   bool oldValue = buffering;
   setBuffering(true);

    // turn buffering ON (temporarily)
    bool oldValue = buffering;
    setBuffering(true);

   // loop through string
   char *p = (char *)s;
   while(*p)
   {
       writeChar(*p++);
   }

    // loop through string
    char *p = (char *)s;
    while(*p)
    {
        writeChar(*p++);
    }

   // reset buffering
   setBuffering(oldValue);

    // reset buffering
    setBuffering(oldValue);

   // flush string
   bFlush();

    // flush string
    bFlush();

   va_list argp;
   char buffer[4096]; // one could hope it's enough

    va_list argp;
    char buffer[4096]; // one could hope it's enough

   va_start( argp, format );

    va_start( argp, format );

   vsprintf(buffer, format, argp);
   cprintf_aux(buffer);

    vsprintf(buffer, format, argp);
    cprintf_aux(buffer);

   va_end(argp);

    va_end(argp);

   // do nothing
   UNUSED( x );
   UNUSED( y );
   UNUSED( lx );
   UNUSED( ly );

    // do nothing
    UNUSED( x );
    UNUSED( y );
    UNUSED( lx );
    UNUSED( ly );

   return cx+1;

    return cx+1;

   return cy+1;

    return cy+1;

   // special case: check for '0' char: map to space
   if (c==0)
      c = ' ';

    // special case: check for '0' char: map to space
    if (c==0)
        c = ' ';

   writeChar(c);

    writeChar(c);

   {

{

   bool shftDown = false;
   bool ctrlDown = false;
   bool altDown  = !!(cKeys & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED));
   // DEBUG
   //fprintf(foo, "Received code %d (%c) with modifiers: %d\n", VirtCode, c, cKeys);

    bool shftDown = false;
    bool ctrlDown = false;
    bool altDown  = !!(cKeys & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED));

   // step 1 - we don't care about shift or control
   if (VirtCode == VK_SHIFT || VirtCode == VK_CONTROL ||
           VirtCode == VK_MENU || VirtCode == VK_CAPITAL ||
           VirtCode == VK_NUMLOCK)
      return 0;

    // step 1 - we don't care about shift or control
    if (VirtCode == VK_SHIFT || VirtCode == VK_CONTROL ||
        VirtCode == VK_MENU || VirtCode == VK_CAPITAL ||
        VirtCode == VK_NUMLOCK)
        return 0;

   // step 2 - translate the <Esc> key to 0x1b
   if (VirtCode == VK_ESCAPE)
      return 0x1b;            // same as it ever was..

    // step 2 - translate the <Esc> key to 0x1b
    if (VirtCode == VK_ESCAPE)
        return 0x1b;            // same as it ever was..

   // step 3 - translate shifted or controlled numeric keypad keys
   if (cKeys & SHIFT_PRESSED)
      shftDown = true;
   if (cKeys & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
      ctrlDown = true;           // control takes precedence over shift

    // step 3 - translate shifted or controlled numeric keypad keys
    if (cKeys & SHIFT_PRESSED)
        shftDown = true;
    if (cKeys & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
        ctrlDown = true;           // control takes precedence over shift

   // hack - translate ^P and ^Q since 16 and 17 are taken by CTRL and SHIFT
   if ((VirtCode == 80 || VirtCode == 81) && ctrlDown)
      return VirtCode & 0x003f;     // shift back down

    // hack - translate ^P and ^Q since 16 and 17 are taken by CTRL and SHIFT
    if ((VirtCode == 80 || VirtCode == 81) && ctrlDown)
        return VirtCode & 0x003f;     // shift back down

   if (VirtCode == VK_DELETE && !ctrlDown)         // assume keypad '.'
      return CK_DELETE;

    if (VirtCode == VK_DELETE && !ctrlDown)         // assume keypad '.'
        return CK_DELETE;

   // see if we're a vkey
   int mkey;
   for(mkey = 0; mkey<VKEY_MAPPINGS; mkey++)
      if (VirtCode == vk_tr[0][mkey]) break;

    // see if we're a vkey
    int mkey;
    for(mkey = 0; mkey<VKEY_MAPPINGS; mkey++)
        if (VirtCode == vk_tr[0][mkey]) break;

   // step 4 - just return the damn key.
   if (mkey == VKEY_MAPPINGS)
   {
      if (c)
          return c;

    // step 4 - just return the damn key.
    if (mkey == VKEY_MAPPINGS)
    {
        if (c)
            return c;

      // ds -- Icky hacks to allow keymaps with funky keys.
      if (ctrlDown)
          VirtCode |= 512;
      if (shftDown)
          VirtCode |= 1024;
      if (altDown)
          VirtCode |= 2048;

        // ds -- Icky hacks to allow keymaps with funky keys.
        if (ctrlDown)
            VirtCode |= 512;
        if (shftDown)
            VirtCode |= 1024;
        if (altDown)
            VirtCode |= 2048;

      // ds -- Cheat and returns 256 + VK if the char is zero. This allows us
      // to use the VK for macros and is on par for evil with the rest of
      // this function anyway.
      return VirtCode | 256;
   }

        // ds -- Cheat and returns 256 + VK if the char is zero. This allows us
        // to use the VK for macros and is on par for evil with the rest of
        // this function anyway.
        return VirtCode | 256;
    }

   // now translate the key.  Dammit.  This is !@#$(*& garbage.

    // now translate the key.  Dammit.  This is !@#$(*& garbage.

   // control key?
   if (ctrlDown)
      return vk_tr[3][mkey];

    // control key?
    if (ctrlDown)
        return vk_tr[3][mkey];

   // shifted?
   if (shftDown)
      return vk_tr[2][mkey];
   return vk_tr[1][mkey];

    // shifted?
    if (shftDown)
        return vk_tr[2][mkey];
    return vk_tr[1][mkey];

       repeat_count -= 1;
       return repeat_key;

        repeat_count -= 1;
        return repeat_key;

    while(1)

    bool waiting_for_event = true;
    while (waiting_for_event)

       CLOCKIN
       if (ReadConsoleInput( inbuf, &ir, 1, &nread) == 0)
           fputs("Error in ReadConsoleInput()!", stderr);
       CLOCKOUT(5)
       if (nread > 0)
       {
          // ignore if it isn't a keyboard event.
          if (ir.EventType == KEY_EVENT)
          {
             kr = &(ir.Event.KeyEvent);
             // ignore if it is a 'key up' - we only want 'key down'
             if (kr->bKeyDown == true)
             {
                key = vk_translate( kr->wVirtualKeyCode, kr->uChar.AsciiChar, kr->dwControlKeyState );
                if (key > 0)

        if (ReadConsoleInput( inbuf, &ir, 1, &nread) == 0)
            fputs("Error in ReadConsoleInput()!", stderr);
        if (nread > 0)
        {
            // ignore if it isn't a keyboard event.
            switch (ir.EventType)
            {
            case KEY_EVENT:
                kr = &(ir.Event.KeyEvent);
                // ignore if it is a 'key up' - we only want 'key down'
                if (kr->bKeyDown == true)

                   repeat_count = kr->wRepeatCount - 1;
                   repeat_key = key;
                   break;

                    key = vk_translate( kr->wVirtualKeyCode,
                                        kr->uChar.AsciiChar,
                                        kr->dwControlKeyState );
                    if (key > 0)
                    {
                        repeat_count = kr->wRepeatCount - 1;
                        repeat_key = key;
                        waiting_for_event = false;
                        break;
                    }

             }
          }
       }

                break;
                
            case WINDOW_BUFFER_SIZE_EVENT:
                w32_handle_resize_event();
                break;
            }
        }

   // turn buffering off temporarily
   const bool oldValue = buffering;
   setBuffering(false);

    // turn buffering off temporarily
    const bool oldValue = buffering;
    setBuffering(false);

   int val = getch();

    int val = getch();

   if (val != 0)
      putch(val);

    if (val != 0)
        putch(val);

   // restore buffering value
   setBuffering(oldValue);

    // restore buffering value
    setBuffering(oldValue);

   return val;

    return val;

   Sleep((DWORD)ms);

    Sleep((DWORD)ms);

   // do nothing
   UNUSED( c );

    // do nothing
    UNUSED( c );

   DWORD nread;
   // set console input to line mode
   setStringInput( true );

    DWORD nread;
    // set console input to line mode
    setStringInput( true );

   // force cursor
   const bool oldValue = cursor_is_enabled;

    // force cursor
    const bool oldValue = cursor_is_enabled;

   if (w32_smart_cursor)
       _setcursortype_internal(true);

    if (w32_smart_cursor)
        _setcursortype_internal(true);

   // set actual screen color to current color
   SetConsoleTextAttribute( outbuf, WIN32COLOR(current_color) );

    // set actual screen color to current color
    SetConsoleTextAttribute( outbuf, WIN32COLOR(current_color) );

   if (ReadConsole( inbuf, buf, (DWORD)(maxlen-1), &nread, NULL) == 0)
      fputs("Error in ReadConsole()!", stderr);

    if (ReadConsole( inbuf, buf, (DWORD)(maxlen-1), &nread, NULL) == 0)
        fputs("Error in ReadConsole()!", stderr);

   // terminate string, then strip CRLF, replace with \0
   buf[maxlen-1] = 0;
   for (unsigned i=(nread<3 ? 0 : nread-3); i<nread; i++)
   {
      if (buf[i] == 0x0A || buf[i] == 0x0D)
      {
         buf[i] = '\0';
         break;
      }

    // terminate string, then strip CRLF, replace with \0
    buf[maxlen-1] = 0;
    for (unsigned i=(nread<3 ? 0 : nread-3); i<nread; i++)
    {
        if (buf[i] == 0x0A || buf[i] == 0x0D)
        {
            buf[i] = '\0';
            break;
        }

   // reset console mode - also flushes if player has typed in
   // too long of a name so we don't get silly garbage on return.
   setStringInput( false );

    // reset console mode - also flushes if player has typed in
    // too long of a name so we don't get silly garbage on return.
    setStringInput( false );

   // restore old cursor
   if (w32_smart_cursor)
       _setcursortype_internal(oldValue);

    // restore old cursor
    if (w32_smart_cursor)
        _setcursortype_internal(oldValue);

   // return # of bytes read
   return (int)nread;

    // return # of bytes read
    return (int)nread;

   bool oldValue = buffering;

    bool oldValue = buffering;

   if (value == false)
   {
       // must flush buffer
       bFlush();
   }
   buffering = value;

    if (value == false)
    {
        // must flush buffer
        bFlush();
    }
    buffering = value;

   return oldValue;

    return oldValue;

    if (crawl_state.waiting_for_comand)

    if (crawl_state.waiting_for_command)

    bool waiting_for_comand; // True when the game is waiting for a command.

    bool waiting_for_command; // True when the game is waiting for a command.

    void (*terminal_resize_check)();

    game_state() : waiting_for_comand(false), terminal_resized(false),

    game_state() : waiting_for_command(false), terminal_resized(false),

                   terminal_resize_handler(NULL)

                   terminal_resize_handler(NULL), terminal_resize_check(NULL)
    {
    }
    void check_term_size() const

        if (terminal_resize_check)
            (*terminal_resize_check)();

    crawl_state.check_term_size();

        crawl_state.waiting_for_comand = true;

        crawl_state.waiting_for_command = true;

        crawl_state.waiting_for_comand = false;

        crawl_state.waiting_for_command = false;