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