key:
    push    .count
    push    1
    push    .event
    push    dword [.stdin]
    call    dword [ReadConsoleInput]
    cmp     word  [.event],1
    jnz     key
    cmp     word  [.down],0
    jnz     key
    ret
.event dw 0
.down  dw 0
.rep   dw 0
.kcode dw 0
.scode dw 0
.char  db 0
.state dd 0  
    

typedef struct _KEY_EVENT_RECORD {
    BOOL bKeyDown;
    WORD wRepeatCount;
    WORD wVirtualKeyCode;
    WORD wVirtualScanCode;
    union {
        WCHAR UnicodeChar;
        CHAR   AsciiChar;
    } uChar;
    DWORD dwControlKeyState;
} KEY_EVENT_RECORD, *PKEY_EVENT_RECORD;

#define KEY_EVENT         0x0001 // Event contains key event record
#define MOUSE_EVENT       0x0002 // Event contains mouse event record
#define WINDOW_BUFFER_SIZE_EVENT 0x0004 // Event contains window change event record
#define MENU_EVENT 0x0008 // Event contains menu event record
#define FOCUS_EVENT 0x0010 // event contains focus change

typedef struct _INPUT_RECORD {
    WORD EventType;
    union {
        KEY_EVENT_RECORD KeyEvent;
        MOUSE_EVENT_RECORD MouseEvent;
        WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent;
        MENU_EVENT_RECORD MenuEvent;
        FOCUS_EVENT_RECORD FocusEvent;
    } Event;
} INPUT_RECORD, *PINPUT_RECORD;

WINBASEAPI
BOOL
WINAPI
ReadConsoleInputA(
    IN HANDLE hConsoleInput,
    OUT PINPUT_RECORD lpBuffer,
    IN DWORD nLength,
    OUT LPDWORD lpNumberOfEventsRead
    );    

proc getch
        invoke  FlushConsoleInputBuffer,[hConsIn]
    @@:
        invoke  ReadConsoleInput,[hConsIn],lpBuffer,1,lpEventsRead
        cmp     [lpBuffer.EventType],KEY_EVENT
        jne     @b
        ret
endp

lpEventsRead dd ?

lpBuffer:
  .EventType dw ?
   rw 7    

struc     EVENTS_UNION {
    virtual
  .MouseEvent             MOUSE_EVENT_RECORD
    end virtual
    virtual
        .WindowBufferSizeEvent  WINDOW_BUFFER_SIZE_RECORD
    end virtual
    virtual
 .MenuEvent              MENU_EVENT_RECORD
    end virtual
    virtual
 .FocusEvent             FOCUS_EVENT_RECORD
    end virtual
       .KeyEvent               KEY_EVENT_RECORD
}    

Then there's resetting window sizes

This microsoft piece of code works satisfying enough under XP & Vista.

        ;------------------------------------
        ;   Win32 Console Application
        ;   -- Resize Console Window
        ;   v0.1 14 Oct 2010
        ;   v0.2 17 Mar 2012
        ;------------------------------------
        ;   Author: Picnic
        ;   Fasm v1.69.42
        ;------------------------------------

        format PE CONSOLE 4.0

        include "include\win32ax.inc"

;------------------------------------------------------------
;
section ".data" data readable writeable
;
;------------------------------------------------------------
        hStdOut dd 0

    struct COORD
        X dw ?
        Y dw ?
    ends

    struct SMALL_RECT
        Left dw ?
        Top dw ?
        Right dw ?
        Bottom dw ?
    ends

;------------------------------------------------------------
;
section ".text" code readable executable
;
;------------------------------------------------------------
main:
        invoke GetStdHandle, STD_OUTPUT_HANDLE
        mov [hStdOut], eax

        stdcall WINDOW, [hStdOut], 60,30

        invoke Sleep, 2000

        invoke ExitProcess, 0


;------------------------------------------------------------
;
proc WINDOW uses ecx edx, handle, x, y
;   Usage:
;       stdcall WINDOW, output_handle, cols, rows
;   Returns:
;       EAX = zero on success, else -1.
;
;------------------------------------------------------------
        local coord COORD
        local rect SMALL_RECT

        ;cmp [x], MIN_COLS
        ;jb .error
        ;cmp [y], MIN_ROWS
        ;jb .error
        ;cmp [x], MAX_COLS
        ;ja .error
        ;cmp [y], MAX_ROWS
        ;ja .error

        cmp [handle], 0
        je .error

        ; Get the largest size we can size the console window to.
        invoke GetLargestConsoleWindowSize, [handle]
        mov [coord], eax

        mov [rect.Left], 0
        mov [rect.Top], 0
        mov [rect.Right], 1
        mov [rect.Bottom], 1

        ; Set window size to 1,1 in order to set any buffer size.
        invoke SetConsoleWindowInfo, [handle], TRUE, addr rect
        test eax, eax
        jz .error

        ; rect.Right = min(x, coord.X) - 1)
        mov eax, [x]
        movzx ecx, word [coord.X]
        sub ecx, eax
        sbb edx, edx
        and ecx, edx
        add eax, ecx
        dec eax
        mov [rect.Right], ax

        ; rect.Bottom = min(y, coord.Y) - 1)
        mov eax, [y]
        movzx ecx, word [coord.Y]
        sub ecx, eax
        sbb edx, edx
        and ecx, edx
        add eax, ecx
        dec eax
        mov [rect.Bottom], ax

        ; Define the new console buffer size.
        mov ax, word [x]
        mov [coord.X], ax
        mov ax, word [y]
        mov [coord.Y], ax

        ; Set console screen buffer size.
        invoke SetConsoleScreenBufferSize, [handle], dword [coord]
        test eax, eax
        jz .error

        ; Set console screen buffer's window size and position.
        invoke SetConsoleWindowInfo, [handle], TRUE, addr rect
        test eax, eax
        jz .error

        xor eax, eax
        ret

            .error:
        mov eax, -1
        ret
endp

.end main 
    

I have a variation on this question. I would like to write a routine that emulates (more or less) the old INKEY$ function found in QuickBasic, FreeBasic and others. Maybe someone has already done similar?? Thanks.

            ;------------------------------------
            ;   Win32 Console Application
            ;   -- How To Obtain a Console Window Handle (HWND)
            ;   http://support.microsoft.com/kb/124103
            ;------------------------------------
            ;   Author: Picnic
            ;------------------------------------

            format PE CONSOLE 4.0

            include "win32ax.inc"

.data
            LINESZ = 1024
            hWnd dd ?

.code
main:
            stdcall GetConsoleHwnd
            mov [hWnd], eax
            ;
            ;
            invoke ExitProcess, 0



proc GetConsoleHwnd uses ecx edx

            local hwndFound dd ?
            local pszNewWindowTitle dd ?
            local pszOldWindowTitle dd ?

            mov eax, LINESZ
            shl eax, 1

            ; Allocate memory.
            invoke LocalAlloc, LPTR, eax
            test eax, eax
            jz .error

            mov [pszOldWindowTitle], eax
            add eax, LINESZ
            mov [pszNewWindowTitle], eax

            ; Fetch current window title.
            invoke GetConsoleTitle, [pszOldWindowTitle], LINESZ
            test eax, eax
            jz .error

            ; Format a "unique" NewWindowTitle.
            cinvoke wsprintf,\
                [pszNewWindowTitle], "%d/%d",\
                <invoke GetTickCount>,\
                <invoke GetCurrentProcessId>

            ; Change current window title.
            invoke SetConsoleTitle, [pszNewWindowTitle]
            test eax, eax
            jz .error

            ; Ensure window title has been updated.
            invoke Sleep, 40

            ; Look for NewWindowTitle.
            invoke FindWindow, 0, [pszNewWindowTitle]
            test eax, eax
            jz .error

            mov [hwndFound], eax

            ; Restore original window title.
            invoke SetConsoleTitle, [pszOldWindowTitle]
            test eax, eax
            jz .error

            ; Free memory.
            invoke LocalFree, [pszOldWindowTitle]
            test eax, eax
            jz .error

            mov eax,  [hwndFound]
            ret

                .error:
            mov eax, -1
            ret
endp

.end main