How to draw lines
There are a few different ways to draw lines. You can make certain assumptions about the lines that you are going to draw, if you are writting them for some of your programs.

Horizontal lines
For example, if you know that you are going to get lines, that are always horizontal then you can write a simple function like this:

void simple_hoz_line(int x1, int x2, int y, char c){
      int counter;
      char far *vid_pointer = (char far*)MK_FP(0xA000, y * 320 + x1);

      for(counter = x1; counter <= x2; counter++, vid_pointer++)
            *vid_pointer=c;
}

The above code, could be used to draw horizontal lines, between two points x1, and x2. However there are some limitations, x1 must be smaller than x2. Also the line, is not clipped against the edges of the screen. If you indicate, a pixel such as (500, 134), it would actually output to (180, 135). This is because, there would be an overflow. You could add checks to the line drawing mechanism, but it would slow it down. The things that you would be looking for, are things such as boundary checking (is all the line on the screen, or even worse, is the line on the screen at all) and co-ordinate switching (if x1 is greater than x2, you might want to swap them around).

Vertical lines
Slightly harder to implement, is the vertical line. This time we can't simply add 1 to the location, as we also need to change the row its on. This can be done by adding 320 to the location.

void simple_v_line(int x, int y1, int y2){
      int counter;
      char far *vid_pointer = (char far*)MK_FP(0xA000, y * 320 + x1);

      for(counter = y1; counter <=y2; counter++, vid_pointer+=320)
            *vid_pointer=c;
}

Other lines
Now, we come to the more complicated part. Those two functions, are fine, if you just want to draw simple lines. If however, you want to have lines, that are not vertical or horizontal then you will need to use longer, slower, and larger functions. The lines you draw in this manner, will not as accurate, as the previous ones. This time, you will only draw groups of pixels, that will approximate a line.

There are two ways of drawing a line. You can use the equation of the line, or the Bresenham's algorithm. The easiest to implement (and the only one I will talk about for now) , is equation of the line way. This is done, by taking the equation in the form y=mx+b . If you forgot all your co-ordinate geometry, this is what it means: b is the y-intercept, ie where the line crosses the y-axis. x, is the x co-ordinate and m is the gradient. This is given by the rise divided by the run: (y2 - y1) / (x2 - x1) . If we want the line to look smooth, we must have two posibilities: the gradient is greater than 1, or the gradient is smaller than one. If the gradient is greater than 1, then we need to find what the x co-ordinate is for each y co-ordinate. If we did the opposite, there would be some gaps in the line. If however the gradient is smaller than 1, then we need to find each y co-ordinate, for each x co-ordinate. Also, when you are finding out the gradient, if the two x co-ordinates are equal, then you will get a division by 0. That is why it is the first thing that is done in my example. If you haven't understood any of what I just said, just look at this:
void complex_line(int x1, int y1, int x2, int y2, char c){
      int counter;
      double temp;
      double signed m;

      if (x2 == x1)
            for (counter = y1; counter <= y2; counter++)
                  plot_pixel(x1, counter, c);
      m = (double)(y2 - y1) / (double)(x2 - x1);
      if (m < 1)
            for (counter = x1; counter <= x2; counter++){
                  temp = m * counter - m * x1 + y1;
                  plot_pixel(counter, (int)temp, c);
            }
      else
            for (counter = y1; counter <= y2; counter++){
                temp = (counter - y1 + (m * x1)) / m;
                plot_pixel((int)temp, counter, c);
            }
}

- By Pascal Hakim