Не получается воспроизвести пример из книги по графике на С

main()
{
    float xA, yA, xB, yB, xC, yC, xD, yD, xxA, yyA, xxB, yyB, xxC, yyC, xxD, yyD, p, q;
    int i;
    p = 0.95;
    q = 1.0 - p;
    xA = 2.0;
    xB = 8.0;
    xC = 8.0;
    xD = 2.0;
    yA = 0.5;
    yB = 0.5;
    yC = 6.5;
    yD = 6.5;
    initgr();
    for (i = 0; i < 50; i++)
    {
        move(xA, yA);
        draw(xB, yB);
        draw(xC, yC);
        draw(xD, yD);
        draw(xA, yA);
        xxA = p * xA + q * xB;
        yyA = p * yA + q * yB;
        xxB = p * xB + q * xC;
        yyB = p * yB + q * yC;
        xxC = p * xC + q * xD;
        yyC = p * yC + q * yD;
        xxD = p * xD + q * xA;
        yyD = p * yD + q * yA;
        xA = xxA;
        xB = xxB;
        xC == xxC;
        xD = xxD;
        yA = yyA;
        yB = yyB;
        yC = yyC;
        yD = yyD;
    }
    endgr();
}

#ifndef __NEWGRAF_H_
#define __NEWGRAF_H_
 
void initgr();
void move(float x, float y);
void draw(float x, float y);
void endgr();
 
extern float curr_x;
extern float curr_y;
 
#endif

#include "newgraf.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
 
float curr_x;
float curr_y;
 
int width;
int height;
 
char * buff; // buffer for image
int coeff = 100; // coeff to multiply x and y
int bpp = 3; // bytes per pixel
 
void pixel(float x, float y) {
    int coor = (y * width + x) * bpp;
    switch (bpp) {
        case 1:
            buff[coor] = 0x0;
            break;
        case 3:
            buff[coor] = 0x0;
            buff[coor+1] = 0x0;
            buff[coor+2] = 0x0;
            break;
        case 4:
            buff[coor] = 0x0;
            buff[coor+1] = 0x0;
            buff[coor+2] = 0x0;
            buff[coor+3] = 0x0;
            break;  
        default:
            break;
    }
}
 
void initgr() {
    curr_x = 0;
    curr_y = 0;
    width = 9*coeff;
    height = 7*coeff;
    int size = width*height*bpp;
    buff = (char*) malloc(size);
    memset(buff, 0xFF, size);
}
 
void move(float x, float y) {
    curr_y = x;
    curr_y = y;
 
}
 
#define roundf(x) floor(x + 0.5f)
 
#define max(a,b) \
   ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a > _b ? _a : _b; })
 
void draw(float x, float y) {
    // [url]http://compgraphics.info/2D/DDA_line.php[/url] , немного адаптированно
    // (1) Целочисленные значения координат начала и конца отрезка, 
    // округленные до ближайшего целого
    int iX1 = roundf(x*coeff);
    int iY1 = roundf(y*coeff);
    int iX2 = roundf(curr_x*coeff);
    int iY2 = roundf(curr_y*coeff);
 
    // (2) Длина и высота линии
    int deltaX = abs(iX1 - iX2);
    int deltaY = abs(iY1 - iY2);
 
    // (3) Считаем минимальное количество итераций, необходимое
    // для отрисовки отрезка. Выбирая максимум из длины и высоты
    // линии, обеспечиваем связность линии
    int length = max(deltaX, deltaY);
// особый случай, на экране закрашивается ровно один пиксел
    if (length == 0)
    {
        pixel(iX1, iY1);
        return;
    }
 
      // (4) Вычисляем приращения на каждом шаге по осям абсцисс и ординат
      double dX = (x - curr_x) * coeff / length;
      double dY = (y - curr_y) * coeff / length;
 
      // (5) Начальные значения
      double xx = curr_x * coeff;
      double yy = curr_y * coeff;
 
      // Основной цикл
      length++;
      while (length--)
      {
            xx += dX;
            yy += dY;
            pixel(roundf(xx), roundf(yy));
      }
 
    curr_x = x;
    curr_y = y;
}
 
void endgr() {
    FILE *f;
    int i;
    unsigned char file[14] = {
        'B','M', // magic
        0,0,0,0, // size in bytes
        0,0, // app data
        0,0, // app data
        40+14,0,0,0 // start of data offset
    };
    unsigned char info[40] = {
        40,0,0,0, // info hd size
        0,0,0,0, // width
        0,0,0,0, // heigth
        1,0, // number color planes
        24,0, // bits per pixel
        0,0,0,0, // compression is none
        0,0,0,0, // image bits size
        0x13,0x0B,0,0, // horz resoluition in pixel / m
        0x13,0x0B,0,0, // vert resolutions (0x03C3 = 96 dpi, 0x0B13 = 72 dpi)
        0,0,0,0, // #colors in pallete
        0,0,0,0, // #important colors
        };
 
    int w=width;
    int h=height;
 
    int padSize  = (4-(w*bpp)%4)%4;
    int sizeData = w*h*bpp + h*padSize;
    int sizeAll  = sizeData + sizeof(file) + sizeof(info);
 
    file[ 2] = (unsigned char)( sizeAll    );
    file[ 3] = (unsigned char)( sizeAll>> 8);
    file[ 4] = (unsigned char)( sizeAll>>16);
    file[ 5] = (unsigned char)( sizeAll>>24);
 
    info[ 4] = (unsigned char)( w   );
    info[ 5] = (unsigned char)( w>> 8);
    info[ 6] = (unsigned char)( w>>16);
    info[ 7] = (unsigned char)( w>>24);
 
    info[ 8] = (unsigned char)( h    );
    info[ 9] = (unsigned char)( h>> 8);
    info[10] = (unsigned char)( h>>16);
    info[11] = (unsigned char)( h>>24);
 
    info[20] = (unsigned char)( sizeData    );
    info[21] = (unsigned char)( sizeData>> 8);
    info[22] = (unsigned char)( sizeData>>16);
    info[23] = (unsigned char)( sizeData>>24);
 
    f = fopen("img.bmp","wb");
    fwrite(file,1,sizeof(file),f);
    fwrite(info,1,sizeof(info),f);
 
 
    unsigned char bmppad[3] = {0,0,0};
 
    for(i=0; i<h; i++)
    {
        fwrite(buff+(w*(h-i-1)*bpp),bpp,w,f);
        fwrite(bmppad,1,(4-(w*bpp)%4)%4,f);
    }
    fclose(f);
 
    free(buff);
}

int length = (deltaX < deltaY ? deltaY : deltaX);