Git

1 /* zeRace dedicated server */
3 #include <SDL_net.h>
4 #include "network.h"
5 #include "car.h"
6 #include "tracklist.h"
8 /* each client has his data */
9 struct _clients
10 {
11   char pseudo[MAXLINELENGTH];
12   int connected;
13   int lasttime;
14   struct _car car;
15   IPaddress address;
16   int dx,dy;
17 } clients [MAX_CLIENTS];
19 /* UDP stuff */
20 UDPsocket udpsock;
21 UDPpacket *packet;
23 struct _tracklist *tracklist;
24 SDL_Surface *fun;
25 SDL_Surface *cars[256];
28 /* return the id of a connected address */
29 int lookup(IPaddress address)
30 {
31   int i;
32   for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected && clients[i].address.host==address.host && clients[i].address.port==address.port) return i;
33   return -1;
34 }
37 /* announce the server on internet */
38 void announce(char *name,int clients)
39 {
40   IPaddress ip;
41   TCPsocket tcpsock;
42   char *temp;
43   char *msg1=
44     "POST /zerace/announce.php HTTP/1.0\n"
45     "Host: royale.zerezo.com\n"
46     "User-Agent: zeRace dedicated server " VERSION "\n"
47     "Content-Type: application/x-www-form-urlencoded\n"
48     "Content-Length: 99999\n"
49     "\n"
50     "version=" VERSION
51     "&port=" PORT
52     "&name=";
53   char *msg2="&clients=";
54   int len,result;
55   
56   printf("announcing server... ");
57   fflush(stdout);
59   if (SDLNet_ResolveHost(&ip,"royale.zerezo.com",80)==-1)
60   {
61     fprintf(stderr,"SDLNet_ResolveHost: %s\n",SDLNet_GetError());
62     return;
63   }
64   
65   tcpsock=SDLNet_TCP_Open(&ip);
66   if (!tcpsock)
67   {
68     fprintf(stderr,"SDLNet_TCP_Open: %s\n",SDLNet_GetError());
69     return;
70   }
72   temp=(char *)malloc(strlen(msg1)+strlen(name)+strlen(msg2)+10);
73   sprintf(temp,"%s%s%s%d\n",msg1,name,msg2,clients);
74   
75   len=strlen(temp);
76   result=SDLNet_TCP_Send(tcpsock,temp,len);
77   if (result<len)
78     fprintf(stderr,"SDLNet_TCP_Send: %s\n", SDLNet_GetError());
79   else
80     printf("done\n");
81   
82   free(temp);
83   SDLNet_TCP_Close(tcpsock);
84 }
87 /* load the car sprite and rotate it for every angles */
88 void zeRace_generate_cars()
89 {
90   int j;
91   SDL_Surface *car;
92   char temp[20]="sprites/carX.png";
93   temp[11]='A';
94   /* load the car sprite */
95   car=IMG_Load(temp);
96   /* and rotate it for all available angles */
97   for (j=0;j<256;j++)
98   {
99     float x,y;
100     float tcos,tsin;
101     if ((cars[j]=SDL_CreateRGBSurface(SDL_SWSURFACE,30,30,32,RMASK,GMASK,BMASK,AMASK))==NULL)
102     {
103       fprintf(stderr,"CreateRGBSurface failed: %s\n",SDL_GetError());
104     };
105     tcos=cos(2*M_PI*j/256);
106     tsin=sin(2*M_PI*j/256);
107     for (x=0;x<cars[j]->w;x++) for (y=0;y<cars[j]->h;y++)
108     {
109       int x2,y2;
110       x2=(x-cars[j]->w/2.0)*tcos+(y-cars[j]->h/2.0)*tsin+car->w/2.0;
111       y2=(x-cars[j]->w/2.0)*tsin-(y-cars[j]->h/2.0)*tcos+car->h/2.0;
112       if (x2>0 && x2<car->w && y2>0 && y2<car->h)
113         putpixel(cars[j],x,y,getpixel(car,x2,y2));
114     }
115   }
116   SDL_FreeSurface(car);
120 /* main program */
121 int main(int argc,char *argv[])
123   int id,i,j,time=0,nb;
124   char *tmp;
125   unsigned char ip[4];
126   int nb_laps,network_speed,pub,col;
127   
128   if (argc!=6)
129   {
130     fprintf(stderr,
131       "Usage: %s 'server_name' nb_laps network_speed (public|private) (col|nocol)\n"
132       "  server_name : the name of the server\n"
133       "  nb_laps : the number of laps to complete for each race\n"
134       "  network_speed : frequency of network messages (1 for fast network, 10 for slow network...)\n"
135       "  private : this server will not be listed in the 'internet games'\n"
136       "  col : the server will compute collisions between cars\n"
137       ,argv[0]
138     );
139     exit(1);
140   }
141   printf("server_name : %s\n",argv[1]);
142   printf("nb_laps : %d\n",nb_laps=atoi(argv[2]));
143   printf("network_speed : %d\n",network_speed=atoi(argv[3]));
144   printf("public : %d\n",pub=strcmp("private",argv[4]));
145   printf("col : %d\n",col=strcmp("nocol",argv[5]));
146   
147   if (!zeRace_get_tracks(&tracklist)) exit(1);
149   if (SDL_Init(0)==-1)
150   {
151     fprintf(stderr,"SDL_Init: %s\n",SDL_GetError());
152     exit(1);
153   };
154   if (SDLNet_Init()==-1)
155   {
156     fprintf(stderr,"SDLNet_Init: %s\n",SDLNet_GetError());
157     exit(2);
158   }
159   
160   udpsock=SDLNet_UDP_Open(atoi(PORT));
161   if (!udpsock)
162   {
163     fprintf(stderr,"SDLNet_UDP_Open: %s\n",SDLNet_GetError());
164     exit(2);
165   }
167   packet=SDLNet_AllocPacket(1024);
168   if (!packet)
169   {
170     fprintf(stderr,"SDLNet_AllocPacket: %s\n",SDLNet_GetError());
171     exit(2);
172   }
173   
174   zeRace_generate_cars();
175   
176   for (;;)
177   {
178     /* announce the server on internet if wanted */
179     nb=0;
180     for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected) nb++;
181     if (pub) announce(argv[1],nb);
182     
183     /* load new track */
184     printf("loading track \"%s\"\n",tracklist->name);
185     fun=IMG_Load(tracklist->function);
186     
187     /* reset clients variables */
188     for (i=0;i<MAX_CLIENTS;i++)
189     {
190       clients[i].lasttime=time;
191       clients[i].car.x=tracklist->x;
192       clients[i].car.y=tracklist->y;
193       clients[i].car.w=30;
194       clients[i].car.h=30;
195       clients[i].car.angle=tracklist->a*2*M_PI/360;
196       clients[i].car.speed=0;
197       clients[i].car.lap=0;
198       clients[i].car.lastcheck=0;
199     }
200     
201     /* tell the clients */
202     tmp=packet->data;
203     strcpy(tmp,"track");
204     tmp+=strlen(tmp)+1;
205     *tmp++=1; /* startup countdown */
206     strcpy(tmp,tracklist->name);
207     tmp+=strlen(tmp)+1;
208     SDLNet_Write32(time,tmp);
209     tmp+=4;
210     SDLNet_Write32(network_speed,tmp);
211     tmp+=4;
212     packet->len=(void *)tmp-(void *)packet->data;
213     for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected)
214     {
215       packet->address=clients[i].address;
216       SDLNet_UDP_Send(udpsock,-1,packet);
217     }
218     
219     /* wait for everybody startup */
220     for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected) break;
221     /* 5000ms for countdown, and 500ms for loading time... */
222     if (i!=MAX_CLIENTS) SDL_Delay(5500);
223     
224     printf("go\n");
225     
226     /* main race loop */
227     for (;;)
228     {
229       int finish=0;
230       
231       /* read all available packets */
232       while (SDLNet_UDP_Recv(udpsock,packet))
233       {
234         /* return the local id based on the address */
235         id=lookup(packet->address);
236         
237         /* look for type of message */
238         tmp=packet->data;
239         
240         /* new connection ? */
241         if (strcmp(tmp,"connect")==0)
242         {
243           /* allready connected ? */
244           if (id!=-1 && clients[id].connected)
245           {
246             /* should not happen */
247             printf("client %d allready connected\n",id);
248           }
249           else
250           for (i=0;i<MAX_CLIENTS;i++) if (!clients[i].connected)
251           {
252             clients[i].address=packet->address;
253             clients[i].connected=1;
254             clients[i].lasttime=time;
255             memset(&clients[i].car,0,sizeof(struct _car));
256             tmp+=strlen(tmp)+1;
257             strcpy(clients[i].pseudo,tmp);
258             tmp+=strlen(tmp)+1;
259             clients[i].car.color=SDLNet_Read16(tmp);
260             clients[i].car.x=tracklist->x;
261             clients[i].car.y=tracklist->y;
262             clients[i].car.w=30;
263             clients[i].car.h=30;
264             clients[i].car.angle=tracklist->a*2*M_PI/360;
265             clients[i].car.speed=0;
266             clients[i].car.lap=0;
267             clients[i].car.lastcheck=0;
268             memcpy(ip,&packet->address.host,4);
269             printf("client %d connected at %d : %d.%d.%d.%d:%d (pseudo : %s, color : %d)\n",i,time,ip[0],ip[1],ip[2],ip[3],packet->address.port,clients[i].pseudo,clients[i].car.color);
270             tmp=packet->data;
271             strcpy(tmp,"track");
272             tmp+=strlen(tmp)+1;
273             *tmp++=0; /* no startup countdown */
274             strcpy(tmp,tracklist->name);
275             tmp+=strlen(tmp)+1;
276             SDLNet_Write32(time,tmp);
277             tmp+=4;
278             SDLNet_Write32(network_speed,tmp);
279             tmp+=4;
280             packet->len=(void *)tmp-(void *)packet->data;
281             SDLNet_UDP_Send(udpsock,-1,packet);
282             break;
283           }
284         }
285         else
286         
287         /* disconnection ? */
288         if (strcmp(tmp,"disconnect")==0 && id!=-1)
289         {
290           clients[id].connected=0;
291           printf("client %d disconnected\n",id);
292         }
293         else
294         
295         /* keys message ? */
296         if (strcmp(tmp,"keys")==0)
297         {
298           if (id==-1 || !clients[id].connected)
299           {
300             /* should not happen */
301             printf("discarded \"keys\" message\n");
302           }
303           else
304           {
305             int temp,x,y,x2,y2;
306             tmp+=strlen(tmp)+1;
307             temp=SDLNet_Read32(tmp);
308             tmp+=4;
309             x=SDLNet_Read32(tmp);
310             tmp+=4;
311             y=SDLNet_Read32(tmp);
312             tmp+=4;
313             if (clients[id].lasttime<=temp)
314             {
315               tmp+=temp-clients[id].lasttime;
316               while (*tmp)
317               {
318                 move_car(&clients[id].car,*tmp-'A',fun);
319                 clients[id].lasttime++;
320                 tmp++;
321               }
322               /* check that the server and the client are still synchronized */
323               x2=clients[id].car.x;
324               y2=clients[id].car.y;
325               if (x!=x2 || y!=y2)
326               {
327                 int round;
328                 /* this should not happen with a perfect network protocol :) */
329                 printf("client %d unsync at %d\n",id,time);
330                 /* instead of dropping the client, we send him a "dumb" collision to resync him */
331                 tmp=packet->data;
332                 strcpy(tmp,"collision");
333                 tmp+=strlen(tmp)+1;
334                 SDLNet_Write32(time,tmp);
335                 tmp+=4;
336                 round=(clients[id].car.x+100)*65536;
337                 clients[id].car.x=(float)round/65536-100;
338                 SDLNet_Write32(round,tmp);
339                 tmp+=4;
340                 round=(clients[id].car.y+100)*65536;
341                 clients[id].car.y=(float)round/65536-100;
342                 SDLNet_Write32(round,tmp);
343                 tmp+=4;
344                 round=(clients[id].car.speed+100)*65536;
345                 clients[id].car.speed=(float)round/65536-100;
346                 SDLNet_Write32(round,tmp);
347                 tmp+=4;
348                 round=(clients[id].car.angle+100)*65536;
349                 clients[id].car.angle=(float)round/65536-100;
350                 SDLNet_Write32(round,tmp);
351                 tmp+=4;
352                 packet->len=(void *)tmp-(void *)packet->data;
353                 packet->address=clients[id].address;
354                 SDLNet_UDP_Send(udpsock,-1,packet);
355                 clients[id].lasttime=time;
356               }
357             }
358           }
359         }
360       }
361       
362       /* check for timeouts */
363       for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected && clients[i].lasttime+MAX_LAG<time)
364       {
365         printf("client %d timeout at %d\n",i,time);
366         packet->address=clients[i].address;
367         strcpy(packet->data,"disconnected");
368         SDLNet_UDP_Send(udpsock,-1,packet);
369         clients[i].connected=0;
370       }
371       
372       /* should we check for collisions ? */
373       if (col)
374       {
375         /* check for collisions */
376         for (i=0;i<MAX_CLIENTS;i++) clients[i].dx=clients[i].dy=0;
377         for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected)
378           for (j=i+1;j<MAX_CLIENTS;j++) if (clients[j].connected)
379             if (i!=j)
380               if (abs(clients[i].car.x-clients[j].car.x)<30 && abs(clients[i].car.y-clients[j].car.y)<30)
381               {
382                 int x1,y1,x2,y2;
383                 for (x1=0;x1<30;x1++)
384                   for (y1=0;y1<30;y1++)
385                     if (getpixel(cars[(unsigned char)(256*clients[i].car.angle/2.0/M_PI)%256],x1,y1)!=0)
386                     {
387                       x2=x1+clients[i].car.x-clients[j].car.x;
388                       y2=y1+clients[i].car.y-clients[j].car.y;
389                       if (x2>0 && x2<30 && y2>0 && y2<30)
390                       {
391                         if (getpixel(cars[(unsigned char)(256*clients[j].car.angle/2.0/M_PI)%256],x2,y2)!=0)
392                         {
393                           if (x1<30/2) { clients[i].dx++; clients[j].dx--; } else { clients[i].dx--; clients[j].dx++; }
394                           if (y1<30/2) { clients[i].dy++; clients[j].dy--; } else { clients[i].dy--; clients[j].dy++; }
395                         }
396                       }
397                     }
398               }
399         
400         /* now compute the collisions */
401         for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected) if (clients[i].dx || clients[i].dy)
402         {
403           Uint32 c;
404           Uint8 g,t;
405           int dx=clients[i].dx;
406           int dy=clients[i].dy;
407           /* do not jump to much */
408           while (abs(dx)>5) dx/=2;
409           while (abs(dy)>5) dy/=2;
410           /* get the pixel color under the center of car in the function map */
411           c=getpixel(fun,clients[i].car.x+dx,clients[i].car.y+dy);
412           /* green layer (road quality) */
413           SDL_GetRGB(c,fun->format,&t,&g,&t);
414           /* if the destination is not a wall and not outside of the track */
415           if (g!=0 && clients[i].car.x>cars[0]->w && clients[i].car.x<fun->w-cars[0]->w && clients[i].car.y>cars[0]->h && clients[i].car.y<fun->h-cars[0]->h)
416           {
417             int round;
418             clients[i].car.x+=dx;
419             clients[i].car.y+=dy;
420             tmp=packet->data;
421             strcpy(tmp,"collision");
422             tmp+=strlen(tmp)+1;
423             SDLNet_Write32(time,tmp);
424             tmp+=4;
425             round=(clients[i].car.x+100)*65536;
426             clients[i].car.x=(float)round/65536-100;
427             SDLNet_Write32(round,tmp);
428             tmp+=4;
429             round=(clients[i].car.y+100)*65536;
430             clients[i].car.y=(float)round/65536-100;
431             SDLNet_Write32(round,tmp);
432             tmp+=4;
433             round=(clients[i].car.speed+100)*65536;
434             clients[i].car.speed=(float)round/65536-100;
435             SDLNet_Write32(round,tmp);
436             tmp+=4;
437             round=(clients[i].car.angle+100)*65536;
438             clients[i].car.angle=(float)round/65536-100;
439             SDLNet_Write32(round,tmp);
440             tmp+=4;
441             packet->len=(void *)tmp-(void *)packet->data;
442             packet->address=clients[i].address;
443             SDLNet_UDP_Send(udpsock,-1,packet);
444             clients[i].lasttime=time;
445           }
446         }
447       }
448       
449       /* send update to clients */
450       if (time%network_speed==0) for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected)
451       {
452         tmp=packet->data;
453         strcpy(tmp,"positions");
454         tmp+=strlen(tmp)+1;
455         SDLNet_Write32(time,tmp);
456         tmp+=4; /* for server time */
457         tmp+=4; /* for client time */
458         tmp+=2; /* for number of cars */
459         nb=0;
460         for (j=0;j<MAX_CLIENTS;j++) if (j!=i && clients[j].connected)
461         {
462           SDLNet_Write16(clients[j].car.x,tmp);
463           tmp+=2;
464           SDLNet_Write16(clients[j].car.y,tmp);
465           tmp+=2;
466           SDLNet_Write16(clients[j].car.angle*1000,tmp);
467           tmp+=2;
468           SDLNet_Write16(clients[j].car.color,tmp);
469           tmp+=2;
470           SDLNet_Write16(clients[j].car.lights_brake,tmp);
471           tmp+=2;
472           SDLNet_Write16(clients[j].car.lights_backwards,tmp);
473           tmp+=2;
474           SDLNet_Write16(clients[j].car.lights_warning,tmp);
475           tmp+=2;
476           nb++;
477         }
478         SDLNet_Write16(nb,packet->data+strlen("positions")+1+4+4);
479         SDLNet_Write32(clients[i].lasttime,packet->data+strlen("positions")+1+4);
480         packet->len=(void *)tmp-(void *)packet->data;
481         packet->address=clients[i].address;
482         SDLNet_UDP_Send(udpsock,-1,packet);
483       }
484       
485       /* did someone finish the track ? */
486       for (i=0;i<MAX_CLIENTS;i++) { if (clients[i].car.lapflag==1) printf("client %d : %d laps\n",i,clients[i].car.lap); clients[i].car.lapflag=0; }
487       for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected && clients[i].car.lap==nb_laps) finish=1;
488       if (finish) break;
489         
490       /* wait like clients */
491       SDL_Delay(7);
492       time++;
493     }
494     
495     /* send the top 10 screen */
496     tmp=packet->data;
497     strcpy(tmp,"finish");
498     tmp+=strlen(tmp)+1;
499     tmp+=2; /* space for number */
500     nb=0;
501     for (i=0;i<10;i++)
502     {
503       int best_sc=-1,best_id;
504       for (j=0;j<MAX_CLIENTS;j++) if (clients[j].connected && clients[j].car.lap*32+clients[j].car.lastcheck>best_sc)
505       {
506         best_sc=clients[j].car.lap*32+clients[j].car.lastcheck;
507         best_id=j;
508       }
509       if (best_sc!=-1)
510       {
511         sprintf(tmp,"%s : %d",clients[best_id].pseudo,best_sc);
512         tmp+=strlen(tmp)+1;
513         SDLNet_Write16(clients[best_id].car.color,tmp);
514         tmp+=2;
515         clients[best_id].car.lap=-1;
516         nb++;
517         printf("top %d : %s - %d\n",nb,clients[best_id].pseudo,best_sc);
518       }
519     }
520     SDLNet_Write16(nb,packet->data+strlen("finish")+1);
521     packet->len=(void *)tmp-(void *)packet->data;
522     for (i=0;i<MAX_CLIENTS;i++) if (clients[i].connected)
523     {
524       packet->address=clients[i].address;
525       SDLNet_UDP_Send(udpsock,-1,packet);
526     }
527     SDL_Delay(5000);
528     
529     SDL_FreeSurface(fun);
530     tracklist=tracklist->next;
531   }
533   return 0;