line(screen, x, y, mouse_x, mouse_y, makecol(255,255,255));

Your problem is so simple, you really should try to think about how to solve it yourself. If you cannot, then you really should get a new hobby.

I do not need animation, I want to be able to drag the line with the mouse like in Paint in real time. The routine that you gave me would draw lots of lines instead of 1.

PS If my problem is so simple why do not you just give the answer?

Because you should really be able to think of it yourself if you ever want to do any serious programming, that's why. Definately not because we don't know how.

Anyway, here's a hint to get you started: you draw a line from (x, y) to the location of the mouse. Then the mouse moves, and you draw a new line to its new position. Your problem? The old line is still there. You figure it out from here.

By the way,

This is not as clear a reference as you might think it is.

Have you ever heard of double buffering? You're supposed to draw from all of your sources to an intermediate bitmap. Then you copy that bitmap to the screen. Once you do that, your problem is trivial.

That's already a better question to ask, because it at least makes it clear that you've actually thought about the problem. This isn't clear in your original message.

Right. On that note, don't expect help from me in the future.

What we have here is a difficulty to exactly know the level of abstraction. I have a strange BASIC tool on my old Mac (68k). It had this funny sprite data type. You could define a variable as a sprite and attach it to a bitmap resource. Then you could perform some draw_sprite function that place the sprite on the screen. And doing draw_sprite again with other coordinates moved the sprite to its new place. So the sprite could be seen only on one place on the screen at a time. A bit like the line drawing thing fatboy2 is asking for.

Programming with Allegro is on a lower abstraction level. "Line writing algorithm" is in the first place wrong terminology for fatboy2's problem. As Matthew said, this is a very simple thing. Only that no one would expect such a function to be incorporated in Allegro's set of drawing primitives functions.

That said, *click*

[branestorming]
On a 1024*768 screen, any line is at its most 1024 pixel, when drawn with do_line(). One could think of actually saving each pixel colour in a 1024 by 2 array.

When line gets first time drawn:
For each pixel in the line, save previous colour in the array and draw the line colour on the pixel. Save the start and end coordinates of the line.

When next line gets drawn:
Redraw the previous line using the saved coordinates for the said line and using the colours saved in the array. After that,
for each pixel in the new line, save previous colour in the array and draw the line colour on the pixel. Save the start and end coordinates of the line.

This might be faster than the double buffering and blitting.
[/branestorming]

• aching head*