Проблема. Книга Андрэ Ламот

int main(){
    abc Q;
    Q.x; // тут ошибка про .x т.к. компилятор не знает про abc
}

float y = 12.12;
LONG x = (LONG)y;

int Load_Animation_BOB(BOB_PTR bob, 
                       int anim_index, 
                       int num_frames, 
                       int *sequence)
{
// this function load an animation sequence for a bob
// the sequence consists of frame indices, the function
// will append a -1 to the end of the list so the display
// software knows when to restart the animation sequence
 
if (!bob)
   return(0);
 
// allocate memory for bob animation
if (!(bob->animations[anim_index] = (int *)malloc((num_frames+1)*sizeof(int))))
   return(0);
 
// load data into 
for (int index=0; index<num_frames; index++)
    bob->animations[anim_index][index] = sequence[index];
 
 
bob->animations[anim_index][index] = -1;
 
 
return(1);
 
}

bob->animations[anim_index][index] = -1;     //не определен index

int index;

for (int index=0; index<num_frames; index++)
        bob->animations[anim_index][index] = sequence[index];

for (int i = 0; i < N; i++)
{
   // код
}
// то тут уже i не доступен

for (int i = 0; i < N; i++)
{
   // код
}

int i = 0;
for (i = 0; i < N; i++)
{
   // код
}
// тут по задумке автора и по мнению компилятора как и надо i видится :-)

// finally the image data itself
_lseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);

//Sunday - Main.cpp
 
#define WIN32_LEAN_AND_MEAN 
#define INITGUID 
 
#include <windows.h>
#include <time.h>
#include <ddraw.h>
 
 
// DEFINES ////////////////////////////////////////////////
 
#define WINDOW_CLASS_NAME "WINCLASS" 
#define WINDOW_TITLE      "Graphics Console"
#define WINDOW_WIDTH      800   
#define WINDOW_HEIGHT     600
 
#define WINDOW_BPP        16    // bitdepth of window (8,16,24,32)
                                // note: if windowed and not
                                // fullscreen then bitdepth must
                                // be same as system bitdepth
                                // also if 8-bit the a pallete
                                // is created and attached
 
#define WINDOWED_APP      0     // 0 not windowed, 1 windowed
 
#define MSG_ERROR \
                MessageBox(NULL, "ERROR", "MSG_ERROR", MB_OK)
 
#define _RGB16BIT565(r, g, b)\
        ((b & 31) + ((g & 63) << 5) + ((r & 31) << 11))
 
#define _RGB32BIT(a, r, g, b)\
                ((b) + ((g) << 8) + ((r) << 16) + ((a) << 24))
 
// PROTOTYPES /////////////////////////////////////////////
 
int Game_Init(void *parms=NULL);
int Game_Shutdown(void *parms=NULL);
int Game_Main(void *parms=NULL);
 
// GLOBALS ////////////////////////////////////////////////
 
LPDIRECTDRAW7 lpdd = NULL;
LPDIRECTDRAWSURFACE7 lpddsprimary = NULL;
LPDIRECTDRAWSURFACE7 lpddsback = NULL;
 
DDSURFACEDESC2 ddsd ;
 
 
HWND main_window_handle = NULL; // save the window handle
HINSTANCE main_instance = NULL; // save the instance
char buffer[256];               // used to print text
int window_closed;
 
 
// FUNCTIONS //////////////////////////////////////////////
 
void Plot16(int x, int y, int red, int green, int blue, UINT *buffer, int mempitch)
{
  buffer[x+y*(mempitch >> 1)] = _RGB16BIT565(red, green, blue);
}
void Plot32(int x, int y, int alpha, int red, int green, int blue,UINT *buffer, int mempitch)
{
    buffer[x+y*(mempitch >> 2)] = _RGB32BIT(alpha, red, green, blue);
}
int Game_Init(void *parms)
{
    if(FAILED(DirectDrawCreateEx(NULL, (void**)&lpdd, IID_IDirectDraw7, NULL)))
        return(0);
 
    if(FAILED(lpdd -> SetCooperativeLevel(main_window_handle, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
        return(0);
 
    if(FAILED(lpdd -> SetDisplayMode(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_BPP,0,0)))
        return(0);
    
    ZeroMemory(&ddsd, sizeof(ddsd));
    ddsd.dwSize     = sizeof(ddsd);
    ddsd.dwFlags        = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
    ddsd.dwBackBufferCount      = 1;
    ddsd.ddsCaps.dwCaps     = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX |DDSCAPS_FLIP;
 
    if(FAILED(lpdd -> CreateSurface(&ddsd, &lpddsprimary, NULL)))
        return(0);
 
    ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
 
    if(FAILED(lpddsprimary -> GetAttachedSurface(&ddsd.ddsCaps, &lpddsback)))
        return(0);
    
    return(1);
}
int Game_Main(void *parms)
{
    if(window_closed)
        return(0);
 
    if(GetAsyncKeyState(VK_ESCAPE))
  {
        PostMessage(main_window_handle, WM_DESTROY,0,0);
        window_closed = 1;
  } 
    
    
    ZeroMemory(&ddsd, sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);
 
    if(FAILED(lpddsprimary -> Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR |  DDLOCK_WAIT, NULL)))
        return(0);
 
    UCHAR *back_buffer = (UCHAR *)ddsd.lpSurface;
 
    if (ddsd.lPitch == WINDOW_WIDTH)
        memset(back_buffer, 0, WINDOW_WIDTH*WINDOW_HEIGHT);
    else
    {
        UCHAR *dest_ptr = back_buffer;
 
        for (int y=0; y<WINDOW_HEIGHT; y++)
        {
            memset(dest_ptr,0,WINDOW_WIDTH);
      dest_ptr+=ddsd.lPitch;
        }
    }
    for(int i=0; i<500; i++)
    {
        int x=rand()%WINDOW_WIDTH;
        int y=rand()%WINDOW_HEIGHT;
 
        back_buffer[x+y*ddsd.lPitch] = _RGB16BIT565(255, 255, 255);
    }
                     
    if(FAILED(lpddsprimary -> Unlock(NULL)))
        return(0);
 
    while (FAILED(lpddsprimary->Flip(NULL, DDFLIP_WAIT)));
 
    Sleep(500);
 
    return(1);
}
int Game_Shutdown(void *parms)
{   
    if(lpddsback)
    {
        lpddsback -> Release();
        lpddsback = NULL;
    }
    if(lpddsprimary)
    {
        lpddsprimary -> Release();
        lpddsprimary = NULL;
    }
    if(lpdd)
    {
        lpdd -> Release();
        lpdd = NULL;
    }
 
    return(1);
}
LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch(msg)
    {   
    case WM_CREATE: 
        {
 
            return(0);
        } break;
   
    case WM_PAINT: 
        {
 
            return(0);
        } break;
 
    case WM_DESTROY: 
        { 
            PostQuitMessage(0);
            return(0);
        } break;
 
    default:break;
 
    }
    return (DefWindowProc(hwnd, msg, wparam, lparam));
}
// WINMAIN ////////////////////////////////////////////////
 
int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hprevinstance,LPSTR lpcmdline, int nshowcmd)
{
    WNDCLASSEX winclass1;
    HWND hwnd;
    MSG msg;
    srand(1);
 
    ZeroMemory(&winclass1, sizeof(winclass1));
    winclass1.lpszClassName     = WINDOW_CLASS_NAME;
    winclass1.lpfnWndProc       = WindowProc;
    winclass1.cbSize        = sizeof(WNDCLASSEX);
    winclass1.hInstance     = hinstance;
    winclass1.hbrBackground     = (HBRUSH)GetStockObject(BLACK_BRUSH);
    winclass1.hCursor       = LoadCursor(NULL, IDC_ARROW);
    winclass1.hIcon     = LoadIcon(NULL, IDI_APPLICATION);
    winclass1.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
    winclass1.style     = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
 
    if(!RegisterClassEx(&winclass1))
        return(MSG_ERROR);
 
    if (!(hwnd = CreateWindowEx(NULL, WINDOW_CLASS_NAME,    
WINDOW_TITLE, WS_POPUP | WS_VISIBLE,0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 
NULL, NULL, hinstance, NULL)))
        return(MSG_ERROR);
 
    main_window_handle = hwnd;
    main_instance      = hinstance;
    
    Game_Init();
 
    while(TRUE)
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if (msg.message == WM_QUIT)
                break;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        Game_Main();
    }
    Game_Shutdown();
    return(msg.wParam);
}

        for(int i=0; i<500; i++) // 500?
        {
                int x=rand()%WINDOW_WIDTH;
                int y=rand()%WINDOW_HEIGHT;
 
                back_buffer[x+y*ddsd.lPitch] = _RGB16BIT565(255, 255, 255); // x+y*ddsd.lPitch ?
        }

//Очистка
    if(ddsd.lPitch == WINDOW_WIDTH)
        memset(ddsd.lpSurface, 0, WINDOW_WIDTH*WINDOW_HEIGHT);
    else
    {
        UCHAR *dest_ptr = (UCHAR *)ddsd.lpSurface;
 
        for (int y=0; y<WINDOW_HEIGHT; y++)
        {
       memset(dest_ptr, 0, WINDOW_WIDTH);
       dest_ptr+=ddsd.lPitch;
        }
    }
//Запись           
    int lpitch32 = (int)(ddsd.lPitch >> 2);
    UINT *back_buffer = (UINT *)ddsd.lpSurface;
 
    for(int index=0; index<100; index++)
    {
        int x=rand()%800;
        int y=rand()%600;
 
        Plot32(x, y, 0, 255, 255, 255, back_buffer, lpitch32);
    }