;=== ACQUIRE THE WINDOW HANDLES ================
  mov          ecx, 20                            ; Init the counter with 20
  xor          edx, edx                           ; Zero-out the helper index

.GetHandles:                                      ; Get all the handles
  invoke       GetStdHandle, -11                  ; -11 for STD_OUTPUT_DEVICE
  mov          [_textModeBuffer+edx], eax         ; Update the labels
  add          edx, 4
  loop         .GetHandles
    

  ;=== ACQUIRE THE WINDOW HANDLES ================
  mov          ecx, 20                            ; Init the counter with 20
  xor          edx, edx                           ; Zero-out the helper index

.GetHandles:                                      ; Get all the handles
  invoke       GetStdHandle, -11                  ; -11 for STD_OUTPUT_DEVICE
  lea          edx, [_textModeBuffer]             ; Load the effective address
  add          edx, 4                             ; Increase the address by 4 <=====
  mov          _textModeBuffer, edx               ; Load the modified address
  mov          [_textModeBuffer], eax             ; Update the labels
  loop         .GetHandles
    

array rd 8 ; reserve 8 32-bit integers

...

mov ebx, array ; ebx is address of first item (you could also use lea ebx, [array])
mov ecx, 8 ; ecx is number of items

loop_start:

push ecx
call some_function ; some value is placed in eax
pop ecx

mov [ebx], eax ; mov eax into "what ebx points to"
add ebx, 4 ; increase ebx by size of dword (so it points to next element)
dec ecx ; decrease counter by 1
cmp ecx, 0 ; compare counter to 0
jnz loop_start ; if it's still non-zero, repeat

    

Code:

;=== ACQUIRE THE WINDOW HANDLES ================
  mov          ecx, 20                            ; Init the counter with 20
  xor          edx, edx                           ; Zero-out the helper index

.GetHandles:                                      ; Get all the handles
  invoke       GetStdHandle, -11                  ; -11 for STD_OUTPUT_DEVICE
  mov          [_textModeBuffer+edx], eax         ; Update the labels
  add          edx, 4
  loop         .GetHandles
    

;=== ACQUIRE THE WINDOW HANDLES ================
  mov          ecx, 20                            ; Init the counter with 20
  mov          ebx, _textModeBuffer

.GetHandles:                                      ; Get all the handles
  push         ecx
  invoke       GetStdHandle, -11                  ; -11 for STD_OUTPUT_DEVICE
  mov          [ebx], eax                         ; Store the handle into [EBX]
  add          ebx, 4                             ; Add 4 bytes
  pop          ecx
  loop         .GetHandles
    

invoke GetStdHandle, -11
mov edi, eax
invoke GetStdHandle, -11
mov esi, eax
invoke GetStdHandle, -11
mov edx, eax
int3
;
; At this point look in debugger at the registers: ESI, EDI, EDX, EAX.
; They all should contain the same value.
;
    

;=== ACQUIRE THE WINDOW HANDLES ================
  mov          edx, _textModeBuffer
  invoke       GetStdHandle, -11                  ; -11 for STD_OUTPUT_DEVICE
  mov          ecx, 20                            ; Init the counter with 20

.GetHandles:                                      ; Get all the handles
  mov          [edx], eax                         ; Store the handle into [EDX]
  add          edx, 4                             ; Add 4 bytes
  loop         .GetHandles
    

By the way, am I doing the color stuff right? I experimented and this is the only way that I know of to have multiple colors. Is there by any chance a better way?

                format PE CONSOLE 4.0

                include "win32axp.inc"

.data
            macro enum [arg] {
                common
                count = 0
                forward
                arg = count
                count = count+1
                }

                enum BLACK, BLUE, GREEN, CYAN, RED, PURPLE, YELLOW,\
                     SYSTEM, GRAY, BRIGHTBLUE, BRIGHTGREEN, BRIGHTCYAN,\
                     BRIGHTRED, BRIGHTPURPLE, BRIGHTYELLOW, WHITE

                hOut dd ?
                dwTemp dd ?

.code
main:
                invoke GetStdHandle, STD_OUTPUT_HANDLE
                mov [hOut], eax

                stdcall setColor, BLUE, BRIGHTYELLOW
                ; print text
                stdcall setColor, RED, WHITE
                ; print text
                stdcall setColor, BLACK, SYSTEM
                ; print text

                invoke ExitProcess, 0



proc setColor uses ecx edx, BGColor, FGColor

                mov eax, [BGColor]
                shl eax, 4
                or eax, [FGColor]

                invoke SetConsoleTextAttribute, [hOut], eax
                ret
endp

.end main   
    

macro SetColor bkColor, txColor
{
  pusha
       invoke  SetConsoleTextAttribute, [glb_HOutput], (bkColor shl 4) or txColor
  popa
}
    

Now, can you tell me what kind of a game you're planning?

Is that a full screen game? Cool stuff btw.

How do you plan to take input from the user?

Do you type the text into some command panel?