#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <assert.h>

char map[70][20];

int count;			/* total count remaining     */
short step;			/* step value for counting   */
short dx, dy;			/* slope or delta in x and y */

int start_x, start_y, end_x, end_y;

int unit_x, unit_y;

static void draw(int x, int y)
{
  printf("(%d,%d) ", x, y);
  fflush(stdout);
  assert(x >= 0 && x < 70);
  assert(y >= 0 && y < 20);
  map[x][y] = 'x';
  unit_x = x;
  unit_y = y;
}

static int round(float a)
{
  return (int) floor(a + 0.5);
}

static void draw_line1(int x0, int y0, int x1, int y1)
{
  int dx = x1 - x0;
  int dy = y1 - y0;
  draw(x0, y0);

  if (abs(dx) > abs(dy)) {	// slope < 1
    float m = (float) dy / (float) dx;	// compute slope
    float b = y0 - m * x0;

    dx = (dx < 0) ? -1 : 1;
    while (x0 != x1) {
      x0 += dx;
      draw(x0, round(m * x0 + b));
    }
  } else if (dy != 0) {		// slope >= 1
    float m = (float) dx / (float) dy;	// compute slope
    float b = x0 - m * y0;
    dy = (dy < 0) ? -1 : 1;
    while (y0 != y1) {
      y0 += dy;
      draw(round(m * y0 + b), y0);
    }
  }
}

static void draw_line2_init(int src_x, int src_y, int dest_x, int dest_y)
{
  int abs_x, abs_y;

  dx = dest_x - src_x;
  abs_x = abs(dx);
  dy = dest_y - src_y;
  abs_y = abs(dy);

  if (abs_x < abs_y) {
    count = ((abs_x == 0) ? 1 : dx) * dy;
    step = count / abs_y;
    count += step / 2;
  } else {
    assert(abs_x != 0);
    count = ((abs_y == 0) ? 1 : dy) * dx;
    step = count / abs_x;
    count += step / 2;
  }
  unit_x = src_x;
  unit_y = src_y;
}

static void draw_line2_next()
{
  int cur_x, cur_y, next_x, next_y;

  cur_x = count / (unit_y == 0 ? 1 : dy);
  cur_y = count / (unit_x == 0 ? 1 : dx);

  count -= step;

  next_x = count / (unit_y == 0 ? 1 : dy);
  next_y = count / (unit_x == 0 ? 1 : dx);

  draw(next_x - cur_x, next_y - cur_y);
}

static void draw_line3_init(int x0, int y0, int x1, int y1)
{
  start_x = x0;
  start_y = y0;
  end_x = x1;
  end_y = y1;

  draw(x0, y0);

  unit_x = start_x;
  unit_y = start_y;
}

static void draw_line3_next()
{
  int dx = end_x - start_x;
  int dy = end_y - start_y;

  if (abs(dx) > abs(dy)) {
    float m = (float) dy / (float) dx;
    float b = start_y - m * start_x;
    int new_unit_x = unit_x + ((end_x < start_x) ? -1 : 1);
    draw(new_unit_x, round(m * new_unit_x + b));
  } else {
    float m = (float) dx / (float) dy;
    float b = start_x - m * start_y;
    int new_unit_y = unit_y + ((end_y < start_y) ? -1 : 1);
    draw(round(m * new_unit_y + b), new_unit_y);
  }
}

int main()
{
  int x, y;
  int START_X = 40, START_Y = 10, END_X = 15, END_Y = 3;

  memset(map, ' ', sizeof(map));
  draw_line1(START_X, START_Y, END_X, END_Y);
  printf("\n");
  for (y = 0; y < 20; y++) {
    for (x = 0; x < 70; x++) {
      printf("%c", map[x][y]);
    }
    printf("\n");
  }


#if 0
  memset(map, ' ', sizeof(map));
  draw_line2_init(START_X, START_Y, END_X, END_Y);
  for (;;) {
    draw_line2_next();
    if (unit_x == END_X && unit_y == END_Y)
      break;
  }
  printf("\n");
  for (y = 0; y < 20; y++) {
    for (x = 0; x < 70; x++) {
      printf("%c", map[x][y]);
    }
    printf("\n");
  }
#endif

  memset(map, ' ', sizeof(map));
  draw_line3_init(START_X, START_Y, END_X, END_Y);
  for (;;) {
    draw_line3_next();
    if (unit_x == END_X && unit_y == END_Y)
      break;
  }
  printf("\n");
  for (y = 0; y < 20; y++) {
    for (x = 0; x < 70; x++) {
      printf("%c", map[x][y]);
    }
    printf("\n");
  }

  return 0;
}