09d5113cf191efce46edfae000300ebe14a708ca
[ponghero.git] / prpong.c
1 #define _GNU_SOURCE
2 #include <math.h>
3 #include <err.h>
4 #include <stdlib.h>
5 #include <stdio.h>
6 #include <stdbool.h>
7 #include <sys/time.h>
8 #include <time.h>
9 #include <limits.h>
10 #include "stdrusty.h"
11 #include "list/list.h"
12 #include <SDL/SDL.h>
13 #include <cwiid.h>
14
15 #define MAX_X CWIID_IR_X_MAX
16 #define MAX_Y CWIID_IR_Y_MAX
17
18 /* Obtained from http://tog.acm.org/GraphicsGems/gemsiii/insectc.c */
19 /* Faster Line Segment Intersection   */
20 /* Franklin Antonio                   */
21
22 /* The use of some short working variables allows this code to run   */
23 /* faster on 16-bit computers, but is not essential.  It should not  */
24 /* affect operation on 32-bit computers.  The short working variables*/
25 /* to not restrict the range of valid input values, as these were    */
26 /* constrained in any case, due to algorithm restrictions.           */
27 static bool lines_intersect(double x1, double y1,
28                             double x2, double y2,
29                             double x3, double y3,
30                             double x4, double y4,
31                             double *x, double *y) 
32 {
33
34         double Ax,Bx,Cx,Ay,By,Cy,d,e,f,num;
35         double x1lo,x1hi,y1lo,y1hi;
36
37         Ax = x2-x1;
38         Bx = x3-x4;
39
40         if(Ax<0) {                                              /* X bound box test*/
41                 x1lo=x2; x1hi=x1;
42         } else {
43                 x1hi=x2; x1lo=x1;
44         }
45         if(Bx>0) {
46                 if(x1hi < x4 || x3 < x1lo) return false;
47         } else {
48                 if(x1hi < x3 || x4 < x1lo) return false;
49         }
50
51         Ay = y2-y1;
52         By = y3-y4;
53
54         if(Ay<0) {                                              /* Y bound box test*/
55                 y1lo=y2; y1hi=y1;
56         } else {
57                 y1hi=y2; y1lo=y1;
58         }
59         if(By>0) {
60                 if(y1hi < y4 || y3 < y1lo) return false;
61         } else {
62                 if(y1hi < y3 || y4 < y1lo) return false;
63         }
64
65
66         Cx = x1-x3;
67         Cy = y1-y3;
68         d = By*Cx - Bx*Cy;                                      /* alpha numerator*/
69         f = Ay*Bx - Ax*By;                                      /* both denominator*/
70         if(f>0) {                                               /* alpha tests*/
71                 if(d<0 || d>f) return false;
72         } else {
73                 if(d>0 || d<f) return false;
74         }
75
76         e = Ax*Cy - Ay*Cx;                                      /* beta numerator*/
77         if(f>0) {                                               /* beta tests*/
78                 if(e<0 || e>f) return false;
79         } else {
80                 if(e>0 || e<f) return false;
81         }
82
83 /*compute intersection coordinates*/
84
85         if(f==0) return false;
86         num = d*Ax;                                             /* numerator */
87         *x = x1 + num / f;                              /* intersection x */
88
89         num = d*Ay;
90         *y = y1 + num / f;                              /* intersection y */
91
92         return true;
93 }
94
95 // A set of very useful macros that you will find in most
96 // code that I write whether I use them in a program or
97 // not.
98
99 #define abs(a) (((a)<0) ? -(a) : (a))
100 #define sign(a) (((a)<0) ? -1 : (a)>0 ? 1 : 0)
101
102 // The following code implements a Bresenham line drawing
103 // algorithm. There are 4 separate routines each optimized
104 // for one of the four pixel depths supported by SDL. SDL
105 // support many pixel formats, but it only support 8, 16,
106 // 24, and 32 bit pixels.
107
108 //----------------------------------------------------------
109
110 // Draw lines in 8 bit surfaces.
111
112 static void line8(SDL_Surface *s, 
113                   int x1, int y1, 
114                   int x2, int y2, 
115                   Uint32 color)
116 {
117   int d;
118   int x;
119   int y;
120   int ax;
121   int ay;
122   int sx;
123   int sy;
124   int dx;
125   int dy;
126
127   Uint8 *lineAddr;
128   Sint32 yOffset;
129
130   dx = x2 - x1;  
131   ax = abs(dx) << 1;  
132   sx = sign(dx);
133
134   dy = y2 - y1;  
135   ay = abs(dy) << 1;  
136   sy = sign(dy);
137   yOffset = sy * s->pitch;
138
139   x = x1;
140   y = y1;
141
142   lineAddr = ((Uint8 *)(s->pixels)) + (y * s->pitch);
143   if (ax>ay)
144   {                      /* x dominant */
145     d = ay - (ax >> 1);
146     for (;;)
147     {
148       if (y >= 0 && y < MAX_Y && x >= 0 && x < MAX_X)
149         *(lineAddr + x) = (Uint8)color;
150
151       if (x == x2)
152       {
153         return;
154       }
155       if (d>=0)
156       {
157         y += sy;
158         lineAddr += yOffset;
159         d -= ax;
160       }
161       x += sx;
162       d += ay;
163     }
164   }
165   else
166   {                      /* y dominant */
167     d = ax - (ay >> 1);
168     for (;;)
169     {
170       if (y >= 0 && y < MAX_Y && x >= 0 && x < MAX_X)
171         *(lineAddr + x) = (Uint8)color;
172
173       if (y == y2)
174       {
175         return;
176       }
177       if (d>=0) 
178       {
179         x += sx;
180         d -= ay;
181       }
182       y += sy;
183       lineAddr += yOffset;
184       d += ax;
185     }
186   }
187 }
188
189 //----------------------------------------------------------
190
191 // Draw lines in 16 bit surfaces. Note that this code will
192 // also work on 15 bit surfaces.
193
194 static void line16(SDL_Surface *s, 
195                    int x1, int y1, 
196                    int x2, int y2, 
197                    Uint32 color)
198 {
199   int d;
200   int x;
201   int y;
202   int ax;
203   int ay;
204   int sx;
205   int sy;
206   int dx;
207   int dy;
208
209   Uint8 *lineAddr;
210   Sint32 yOffset;
211
212   dx = x2 - x1;  
213   ax = abs(dx) << 1;  
214   sx = sign(dx);
215
216   dy = y2 - y1;  
217   ay = abs(dy) << 1;  
218   sy = sign(dy);
219   yOffset = sy * s->pitch;
220
221   x = x1;
222   y = y1;
223
224   lineAddr = ((Uint8 *)s->pixels) + (y * s->pitch);
225   if (ax>ay)
226   {                      /* x dominant */
227     d = ay - (ax >> 1);
228     for (;;)
229     {
230       if (y >= 0 && y < MAX_Y && x >= 0 && x < MAX_X)
231         *((Uint16 *)(lineAddr + (x << 1))) = (Uint16)color;
232
233       if (x == x2)
234       {
235         return;
236       }
237       if (d>=0)
238       {
239         y += sy;
240         lineAddr += yOffset;
241         d -= ax;
242       }
243       x += sx;
244       d += ay;
245     }
246   }
247   else
248   {                      /* y dominant */
249     d = ax - (ay >> 1);
250     for (;;)
251     {
252       if (y >= 0 && y < MAX_Y && x >= 0 && x < MAX_X)
253         *((Uint16 *)(lineAddr + (x << 1))) = (Uint16)color;
254
255       if (y == y2)
256       {
257         return;
258       }
259       if (d>=0) 
260       {
261         x += sx;
262         d -= ay;
263       }
264       y += sy;
265       lineAddr += yOffset;
266       d += ax;
267     }
268   }
269 }
270
271 //----------------------------------------------------------
272
273 // Draw lines in 24 bit surfaces. 24 bit surfaces require
274 // special handling because the pixels don't fall on even
275 // address boundaries. Instead of being able to store a
276 // single byte, word, or long you have to store 3
277 // individual bytes. As a result 24 bit graphics is slower
278 // than the other pixel sizes.
279
280 static void line24(SDL_Surface *s, 
281                    int x1, int y1, 
282                    int x2, int y2, 
283                    Uint32 color)
284 {
285   int d;
286   int x;
287   int y;
288   int ax;
289   int ay;
290   int sx;
291   int sy;
292   int dx;
293   int dy;
294
295   Uint8 *lineAddr;
296   Sint32 yOffset;
297
298 #if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
299   color <<= 8;
300 #endif
301
302   dx = x2 - x1;  
303   ax = abs(dx) << 1;  
304   sx = sign(dx);
305
306   dy = y2 - y1;  
307   ay = abs(dy) << 1;  
308   sy = sign(dy);
309   yOffset = sy * s->pitch;
310
311   x = x1;
312   y = y1;
313
314   lineAddr = ((Uint8 *)(s->pixels)) + (y * s->pitch);
315   if (ax>ay)
316   {                      /* x dominant */
317     d = ay - (ax >> 1);
318     for (;;)
319     {
320       Uint8 *p = (lineAddr + (x * 3));
321       if (y >= 0 && y < MAX_Y && x >= 0 && x < MAX_X)
322         memcpy(p, &color, 3);
323
324       if (x == x2)
325       {
326         return;
327       }
328       if (d>=0)
329       {
330         y += sy;
331         lineAddr += yOffset;
332         d -= ax;
333       }
334       x += sx;
335       d += ay;
336     }
337   }
338   else
339   {                      /* y dominant */
340     d = ax - (ay >> 1);
341     for (;;)
342     {
343       Uint8 *p = (lineAddr + (x * 3));
344       if (y >= 0 && y < MAX_Y && x >= 0 && x < MAX_X)
345         memcpy(p, &color, 3);
346
347       if (y == y2)
348       {
349         return;
350       }
351       if (d>=0) 
352       {
353         x += sx;
354         d -= ay;
355       }
356       y += sy;
357       lineAddr += yOffset;
358       d += ax;
359     }
360   }
361 }
362
363 //----------------------------------------------------------
364
365 // Draw lines in 32 bit surfaces. Note that this routine
366 // ignores alpha values. It writes them into the surface
367 // if they are included in the pixel, but does nothing
368 // else with them.
369
370 static void line32(SDL_Surface *s, 
371                    int x1, int y1, 
372                    int x2, int y2, 
373                    Uint32 color)
374 {
375   int d;
376   int x;
377   int y;
378   int ax;
379   int ay;
380   int sx;
381   int sy;
382   int dx;
383   int dy;
384
385   Uint8 *lineAddr;
386   Sint32 yOffset;
387
388   dx = x2 - x1;  
389   ax = abs(dx) << 1;  
390   sx = sign(dx);
391
392   dy = y2 - y1;  
393   ay = abs(dy) << 1;  
394   sy = sign(dy);
395   yOffset = sy * s->pitch;
396
397   x = x1;
398   y = y1;
399
400   lineAddr = ((Uint8 *)(s->pixels)) + (y * s->pitch);
401   if (ax>ay)
402   {                      /* x dominant */
403     d = ay - (ax >> 1);
404     for (;;)
405     {
406       if (y >= 0 && y < MAX_Y && x >= 0 && x < MAX_X)
407         *((Uint32 *)(lineAddr + (x << 2))) = (Uint32)color;
408
409       if (x == x2)
410       {
411         return;
412       }
413       if (d>=0)
414       {
415         y += sy;
416         lineAddr += yOffset;
417         d -= ax;
418       }
419       x += sx;
420       d += ay;
421     }
422   }
423   else
424   {                      /* y dominant */
425     d = ax - (ay >> 1);
426     for (;;)
427     {
428       if (y >= 0 && y < MAX_Y && x >= 0 && x < MAX_X)
429         *((Uint32 *)(lineAddr + (x << 2))) = (Uint32)color;
430
431       if (y == y2)
432       {
433         return;
434       }
435       if (d>=0) 
436       {
437         x += sx;
438         d -= ay;
439       }
440       y += sy;
441       lineAddr += yOffset;
442       d += ax;
443     }
444   }
445 }
446
447 //----------------------------------------------------------
448
449 // Examine the depth of a surface and select a line
450 // drawing routine optimized for the bytes/pixel of the
451 // surface.
452
453 static void line(SDL_Surface *s, 
454                  int x1, int y1, 
455                  int x2, int y2, 
456                  Uint32 color)
457 {
458   switch (s->format->BytesPerPixel)
459   {
460   case 1:
461     line8(s, x1, y1, x2, y2, color);
462     break;
463   case 2:
464     line16(s, x1, y1, x2, y2, color);
465     break;
466   case 3:
467     line24(s, x1, y1, x2, y2, color);
468     break;
469   case 4:
470     line32(s, x1, y1, x2, y2, color);
471     break;
472   }
473 }
474
475 #if 1
476 struct coord
477 {
478         double x;
479         double y;
480 };
481
482 struct ball
483 {
484         struct coord pos;
485         struct coord move;
486 };
487
488 struct line_segment
489 {
490         struct coord start, end;
491         struct list_node list;
492         bool ignore;
493         struct timeval expires;
494 };
495
496 static void thick_line(SDL_Surface *s, const struct line_segment *l,
497                        unsigned color)
498 {
499         struct line_segment adj;
500         int x, y, minx = MAX_X, miny = MAX_Y, maxx = 0, maxy = 0;
501
502         SDL_LockSurface(s);
503
504         /* Cheap hack */
505         for (x = -1; x < 2; x++) {
506                 for (y = -1; y < 2; y++) {
507                         adj.start.x = l->start.x + x;
508                         adj.end.x = l->end.x + x;
509                         adj.start.y = l->start.y + y;
510                         adj.end.y = l->end.y + y;
511
512                         if (adj.start.x < minx)
513                                 minx = adj.start.x;
514                         if (adj.start.x > maxx)
515                                 maxx = adj.start.x;
516                         if (adj.start.y < miny)
517                                 miny = adj.start.y;
518                         if (adj.start.y > maxy)
519                                 maxy = adj.start.y;
520                         if (adj.end.x < minx)
521                                 minx = adj.end.x;
522                         if (adj.end.x > maxx)
523                                 maxx = adj.end.x;
524                         if (adj.end.y < miny)
525                                 miny = adj.end.y;
526                         if (adj.end.y > maxy)
527                                 maxy = adj.end.y;
528
529                         line(s, adj.start.x, adj.start.y, adj.end.x, adj.end.y,
530                              color);
531                 }
532         }
533
534         if (minx < 0)
535                 minx = 0;
536         if (miny < 0)
537                 miny = 0;
538         if (maxx >= MAX_X)
539                 maxx = MAX_X-1;
540         if (maxy >= MAX_Y)
541                 maxy = MAX_Y-1;
542         SDL_UpdateRect(s, minx, miny, maxx-minx, maxy-miny);
543         SDL_UnlockSurface(s);
544 }
545
546 static bool intersect(const struct coord *c1, const struct coord *c2,
547                       const struct line_segment *seg, struct coord *intersect)
548 {
549         return lines_intersect(c1->x, c1->y, c2->x, c2->y,
550                                seg->start.x, seg->start.y,
551                                seg->end.x, seg->end.y,
552                                &intersect->x, &intersect->y);
553 }
554
555 static double dist(const struct coord *c1, const struct coord *c2)
556 {
557         float x = (c1->x - c2->x), y = (c1->y - c2->y);
558         return sqrt(x * x + y * y);
559 }
560
561 static unsigned rad_to_deg(double rad)
562 {
563         return ((unsigned)(rad / M_PI * 180) + 360) % 360;
564 }
565
566 static void bounce(struct ball *ball, const struct line_segment *line,
567                    struct coord *remainder)
568 {
569         double len, speed, lang, iang, oang;
570         struct coord isect, new;
571
572         new.x = ball->pos.x + ball->move.x;
573         new.y = ball->pos.y + ball->move.y;
574
575         /* How far were we supposed to move ball? */
576         len = sqrt(remainder->x * remainder->x + remainder->y * remainder->y);
577
578         /* How far is it to intersection? */
579         intersect(&ball->pos, &new, line, &isect);
580         len -= dist(&ball->pos, &isect);
581
582         /* Move ball to intersection. */
583         ball->pos = isect;
584         printf("ball is now at %f,%f\n", ball->pos.x, ball->pos.y);
585
586         /* Outgoing angle = 2 * line angle - incident angle. */
587         lang = atan2(line->end.x - line->start.x, line->end.y - line->start.y);
588         iang = atan2(ball->move.x, ball->move.y);
589         oang = 2 * lang - iang, 2*M_PI;
590         printf("lang = %u, iang = %u, oang=%u\n", 
591                rad_to_deg(lang),
592                rad_to_deg(iang),
593                rad_to_deg(oang));
594
595         /* Set new direction for ball, at same speed */
596         speed = sqrt(ball->move.x * ball->move.x + ball->move.y * ball->move.y);
597         speed *= 1.01;
598         ball->move.x = sin(oang) * speed;
599         ball->move.y = cos(oang) * speed;
600
601         /* Set remainder. */
602         remainder->x = sin(oang) * len;
603         remainder->y = cos(oang) * len;
604         printf("len = %f, remainder = %f,%f\n", len, remainder->x, remainder->y);
605 }
606
607 static struct line_segment border[] = {
608         { { 0, 0, }, { MAX_X-1, 0 } },
609         { { MAX_X-1, 0, }, { MAX_X-1, MAX_Y-1 } },
610         { { MAX_X-1, MAX_Y-1, }, { 0, MAX_Y-1 } },
611         { { 0, MAX_Y-1, }, { 0, 0 } },
612 };
613
614 static inline float deg_to_rad(float degrees)
615 {
616         return degrees * M_PI / 180;
617 }
618
619 static SDL_Surface *sub_surface(SDL_Surface *screen, int w, int h)
620 {
621         return SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
622                                     screen->format->BitsPerPixel,
623                                     screen->format->Rmask,
624                                     screen->format->Gmask,
625                                     screen->format->Bmask,
626                                     screen->format->Amask);
627 }
628
629 static SDL_Surface *ball_surface(SDL_Surface *screen)
630 {
631         SDL_Surface *ball;
632
633         /* Just like the screen surface. */
634         ball = sub_surface(screen, 5, 5);
635
636         /* Lock the surface */
637         SDL_LockSurface(ball);
638
639         /* Black, white corners. */
640         memset(ball->pixels, 0x00, ball->pitch * 5);
641         line(ball, 0, 0, 0, 0, 0xFFFFFFFF);
642         line(ball, 4, 0, 4, 0, 0xFFFFFFFF);
643         line(ball, 0, 4, 0, 4, 0xFFFFFFFF);
644         line(ball, 4, 4, 4, 4, 0xFFFFFFFF);
645         SDL_UnlockSurface(ball);
646
647         return ball;
648 }
649
650 static void clear_ignore(struct list_head *lines)
651 {
652         struct line_segment *i;
653         printf("Unignoring...\n");
654         list_for_each(lines, i, list)
655                 i->ignore = false;
656 }
657
658 int main(int argc, char *argv[])
659 {
660         struct ball ball;
661         SDL_Surface *screen, *ballsur, *savesur = NULL;
662         Uint8  video_bpp;
663         Uint32 videoflags;
664         unsigned int i;
665         SDL_Rect rect;
666         bool creating_lines = false;
667         struct timeval line_life = { 5, 0 };
668         LIST_HEAD(lines);
669
670         if (argc != 5)
671                 errx(1, "Usage: %s ballx bally ballangle ballspeed\n"
672                      "   Where ballangle is 0 for north, 90 for east, etc\n",
673                         argv[0]);
674
675         ball.pos.x = atol(argv[1]);
676         ball.pos.y = atol(argv[2]);
677         ball.move.x = sin(deg_to_rad(atof(argv[3]))) * atol(argv[4]);
678         ball.move.y = cos(deg_to_rad(atof(argv[3]))) * atol(argv[4]);
679         printf("ball move = %f,%f\n", ball.move.x, ball.move.y);
680
681         /* Initialize SDL */
682         if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
683                 fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
684                 return(1);
685         }
686
687         video_bpp = 0;
688         videoflags = SDL_SWSURFACE;
689
690         /* Set 640x480 video mode */
691         if ( (screen=SDL_SetVideoMode(MAX_X,MAX_Y,video_bpp,videoflags)) == NULL ) {
692                 errx(1, "Couldn't set %dx%dx%d video mode: %s",
693                      MAX_X, MAX_Y,video_bpp, SDL_GetError());
694         }
695
696         /* Set the surface pixels and refresh! */
697         if ( SDL_LockSurface(screen) < 0 ) {
698                 errx(1, "Couldn't lock the display surface: %s",
699                      SDL_GetError());
700         }
701         /* White. */
702         memset(screen->pixels, 0xFF, screen->pitch * screen->h);
703
704         SDL_UnlockSurface(screen);
705         SDL_UpdateRect(screen, 0, 0, 0, 0);
706
707         /* Draw borders, put them in list. */
708         for (i = 0; i < ARRAY_SIZE(border); i++) {
709                 border[i].ignore = false;
710                 border[i].expires.tv_sec = LONG_MAX;
711                 border[i].expires.tv_usec = 0;
712                 list_add(&lines, &border[i].list);
713                 thick_line(screen, &border[i], 0);
714         }
715
716         ballsur = ball_surface(screen);
717
718         for (;;) {
719                 struct coord new, isect, move = ball.move;
720                 struct line_segment *best_l, *l, *next;
721                 double best_d;
722                 SDL_Event event;
723                 struct timeval now;
724
725                 gettimeofday(&now, NULL);
726
727                 /* Expire lines */
728                 list_for_each_safe(&lines, l, next, list) {
729                         if (timercmp(&l->expires, &now, <)) {
730                                 list_del(&l->list);
731                                 /* FIXME: Undraw properly. */
732                                 thick_line(screen, l, 0xFFFFFFFF);
733                                 free(l);
734                         }
735                 }
736
737         again:
738                 best_d = MAX_X + MAX_Y;
739                 best_l = NULL;
740                 new.x = ball.pos.x + move.x;
741                 new.y = ball.pos.y + move.y;
742
743                 list_for_each(&lines, l, list) {
744                         if (!l->ignore && intersect(&ball.pos, &new, l, &isect)) {
745                                 double d;
746                                 d = dist(&ball.pos, &isect);
747                                 if (d < best_d) {
748                                         best_l = l;
749                                         best_d = d;
750                                 }
751                         }
752                 }
753
754                 if (best_l) {
755                         printf("Ball bouncing off (%f,%f %f,%f)!\n",
756                                best_l->start.x, best_l->start.y,
757                                best_l->end.x, best_l->end.y);
758                         bounce(&ball, best_l, &move);
759
760                         /* If we moved, stop ignoring lines. */
761                         if (move.x > 0.001 || move.y > 0.001)
762                                 clear_ignore(&lines);
763
764                         /* Don't hit the same line twice. */
765                         printf("Ignoring that line\n");
766                         best_l->ignore = true;
767                         goto again;
768                 }
769
770                 if (move.x > 0.001 || move.y > 0.001) {
771                         clear_ignore(&lines);
772                         printf("Moving by %f,%f to %f,%f\n", move.x, move.y, new.x, new.y);
773                 }
774
775                 /* Restore what was there before ball. */
776                 if (savesur) {
777                         SDL_BlitSurface(savesur, NULL, screen, &rect);
778                         SDL_UpdateRect(screen, rect.x, rect.y, rect.w, rect.h);
779                 } else {
780                         savesur = sub_surface(screen, ballsur->w, ballsur->h);
781                 }
782
783                 /* Save away image under new ball. */
784                 rect.w = ballsur->w;
785                 rect.h = ballsur->h;
786                 rect.x = new.x - ballsur->w/2;
787                 rect.y = new.y - ballsur->h/2;
788                 SDL_BlitSurface(screen, &rect, savesur, NULL);
789
790                 /* Draw new ball */
791                 SDL_BlitSurface(ballsur, NULL, screen, &rect);
792                 SDL_UpdateRect(screen, rect.x, rect.y, rect.w, rect.h);
793                 /* That SDL_BlitSurface can crop rect. */
794                 rect.x = new.x - ballsur->w/2;
795                 rect.y = new.y - ballsur->h/2;
796                 ball.pos = new;
797                 SDL_Delay(25);
798
799                 while (SDL_PollEvent(&event)) {
800                         if (event.type == SDL_QUIT) {
801                                 SDL_Quit();
802                                 return 0;
803                         }
804                         if (event.type == SDL_MOUSEBUTTONDOWN)
805                                 creating_lines = true;
806                         else if (event.type == SDL_MOUSEBUTTONUP)
807                                 creating_lines = false;
808
809                         if (creating_lines && event.type == SDL_MOUSEMOTION) {
810                                 struct line_segment *n = malloc(sizeof(*n));
811                                 n->start.x = event.motion.x - event.motion.xrel;
812                                 n->start.y = event.motion.y - event.motion.yrel;
813                                 n->end.x = event.motion.x;
814                                 n->end.y = event.motion.y;
815                                 n->ignore = false;
816                                 timeradd(&now, &line_life, &n->expires);
817                                 list_add_tail(&lines, &n->list);
818                                 thick_line(screen, n, 0);
819                         }
820                 }
821         }
822 }
823 #endif