Snippets for 0verkill 0.16 from FreeBSD 150arm64

Sourced from https://pkg-status.freebsd.org/ampere5/data/latest-per-pkg/0verkill/0.16_2/150arm64-default.log.

• ./error.h:55:9: warning: passing 'char[45]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     55 |                 error("ERROR: out of memory (malloc returned NULL)\n");
        |                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• ./error.h:66:9: warning: passing 'char[45]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     66 |                 error("ERROR: out of memory (calloc returned NULL)\n");
        |                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• ./error.h:76:3: warning: assigning to 'unsigned char *' from 'char[10]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     76 |                 internal("mem_free(NULL)");
        |                 ^~~~~~~~
  

• ./error.h:76:12: warning: passing 'char[15]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     76 |                 internal("mem_free(NULL)");
        |                          ^~~~~~~~~~~~~~~~
  

• ./error.h:86:3: warning: assigning to 'unsigned char *' from 'char[10]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     86 |                 internal("mem_realloc(NULL, %d)", size);
        |                 ^~~~~~~~
  

• ./error.h:86:12: warning: passing 'char[22]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     86 |                 internal("mem_realloc(NULL, %d)", size);
        |                          ^~~~~~~~~~~~~~~~~~~~~~~
  

• ./error.h:94:9: warning: passing 'char[46]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     94 |                 error("ERROR: out of memory (realloc returned NULL)\n");
        |                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• ./error.h:100:75: warning: explicitly assigning value of variable of type 'unsigned char *' to itself [-Wself-assign]
    100 | static inline void *debug_mem_alloc(unsigned char *f, int l, size_t s) { f=f; l=l; return mem_alloc(s); }
        |                                                                          ~^~
  

• ./error.h:100:80: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    100 | static inline void *debug_mem_alloc(unsigned char *f, int l, size_t s) { f=f; l=l; return mem_alloc(s); }
        |                                                                               ~^~
  

• ./error.h:101:76: warning: explicitly assigning value of variable of type 'unsigned char *' to itself [-Wself-assign]
    101 | static inline void *debug_mem_calloc(unsigned char *f, int l, size_t s) { f=f; l=l; return mem_calloc(s); }
        |                                                                           ~^~
  

• ./error.h:101:81: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    101 | static inline void *debug_mem_calloc(unsigned char *f, int l, size_t s) { f=f; l=l; return mem_calloc(s); }
        |                                                                                ~^~
  

• ./error.h:102:72: warning: explicitly assigning value of variable of type 'unsigned char *' to itself [-Wself-assign]
    102 | static inline void debug_mem_free(unsigned char *f, int l, void *p) { f=f; l=l; mem_free(p); }
        |                                                                       ~^~
  

• ./error.h:102:77: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    102 | static inline void debug_mem_free(unsigned char *f, int l, void *p) { f=f; l=l; mem_free(p); }
        |                                                                            ~^~
  

• ./error.h:103:86: warning: explicitly assigning value of variable of type 'unsigned char *' to itself [-Wself-assign]
    103 | static inline void *debug_mem_realloc(unsigned char *f, int l, void *p, size_t s) { f=f; l=l; return mem_realloc(p, s); }
        |                                                                                     ~^~
  

• ./error.h:103:91: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    103 | static inline void *debug_mem_realloc(unsigned char *f, int l, void *p, size_t s) { f=f; l=l; return mem_realloc(p, s); }
        |                                                                                          ~^~
  

• ./error.h:104:72: warning: explicitly assigning value of variable of type 'void *' to itself [-Wself-assign]
    104 | static inline void set_mem_comment(void *p, unsigned char *c, int l) {p=p; c=c; l=l;}
        |                                                                       ~^~
  

• ./error.h:104:77: warning: explicitly assigning value of variable of type 'unsigned char *' to itself [-Wself-assign]
    104 | static inline void set_mem_comment(void *p, unsigned char *c, int l) {p=p; c=c; l=l;}
        |                                                                            ~^~
  

• ./error.h:104:82: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    104 | static inline void set_mem_comment(void *p, unsigned char *c, int l) {p=p; c=c; l=l;}
        |                                                                                 ~^~
  

• client.c:194:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    194 |         snprintf(txt,sizeof(txt),"%s/%s",getenv("HOME"),CFG_FILE);
        |                  ^~~
  

• client.c:198:15: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    198 |         stream=fopen(txt,"r");
        |                      ^~~
  

• client.c:201:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    201 |         if (!fgets(txt,MAX_HOST_LEN+2,stream))
        |                    ^~~
  

• client.c:203:11: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    203 |         a=strlen(txt);
        |                  ^~~
  

• client.c:205:25: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    205 |         memcpy(host,txt,strlen(txt)+1);
        |                                ^~~
  

• client.c:207:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    207 |         if (!fgets(txt,MAX_NAME_LEN+2,stream))
        |                    ^~~
  

• client.c:209:11: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    209 |         a=strlen(txt);
        |                  ^~~
  

• client.c:211:25: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    211 |         memcpy(name,txt,strlen(txt)+1);
        |                                ^~~
  

• client.c:212:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    212 |         if (!fgets(txt,256,stream))
        |                    ^~~
  

• client.c:214:16: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    214 |         *color=strtol(txt,0,10);
        |                       ^~~
  

• client.c:226:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    226 |         snprintf(txt,sizeof(txt),"%s/%s",getenv("HOME"),CFG_FILE);
        |                  ^~~
  

• client.c:230:15: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    230 |         stream=fopen(txt,"w");
        |                      ^~~
  

• client.c:387:15: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    387 |         int l=strlen(name)+1;
        |                      ^~~~
  

• client.c:844:67: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    844 |                                                         double2int(p->next->member.x-hero->x)+SCREEN_XOFFSET+fore+((int)(p->next->member.data)&255),
        |                                                                                                                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• client.c:845:63: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    845 |                                                         double2int(p->next->member.y-hero->y)+SCREEN_YOFFSET+(((int)(p->next->member.data)>>8)&255),
        |                                                                                                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• client.c:846:65: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    846 |                                                         sprites[hit_sprite].positions+sprites[hit_sprite].steps[((int)p->next->member.data)>>16],
        |                                                                                                                  ^~~~~~~~~~~~~~~~~~~~~~~~~
  

• client.c:854:61: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    854 |                                                 double2int(p->next->member.x-hero->x)+SCREEN_XOFFSET+((int)(p->next->member.data)&255),
        |                                                                                                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• client.c:855:62: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    855 |                                                 double2int(p->next->member.y-hero->y)+SCREEN_YOFFSET+(((int)(p->next->member.data)>>8)&255),
        |                                                                                                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• client.c:856:64: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    856 |                                                 sprites[hit_sprite].positions+sprites[hit_sprite].steps[((int)p->next->member.data)>>16],
        |                                                                                                          ^~~~~~~~~~~~~~~~~~~~~~~~~
  

• client.c:892:22: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    892 |                                         SCREEN_XOFFSET+((int)(hero->data)&255),
        |                                                         ^~~~~~~~~~~~~~~~~
  

• client.c:893:23: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    893 |                                         SCREEN_YOFFSET+(((int)(hero->data)>>8)&255),
        |                                                          ^~~~~~~~~~~~~~~~~
  

• client.c:894:63: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    894 |                                         sprites[hit_sprite].positions+sprites[hit_sprite].steps[((int)hero->data)>>16],
        |                                                                                                  ^~~~~~~~~~~~~~~
  

• client.c:901:21: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    901 |                                 SCREEN_XOFFSET+((int)(hero->data)&255),
        |                                                 ^~~~~~~~~~~~~~~~~
  

• client.c:902:22: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    902 |                                 SCREEN_YOFFSET+(((int)(hero->data)>>8)&255),
        |                                                  ^~~~~~~~~~~~~~~~~
  

• client.c:903:62: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
    903 |                                 sprites[hit_sprite].positions+sprites[hit_sprite].steps[((int)hero->data)>>16],
        |                                                                                          ^~~~~~~~~~~~~~~
  

• client.c:921:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    921 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,LEVEL_SPRITES_SUFFIX);
        |                  ^~~
  

• client.c:923:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    923 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,STATIC_DATA_SUFFIX);
        |                  ^~~
  

• client.c:1142:19: warning: cast to 'void *' from smaller integer type 'int' [-Wint-to-void-pointer-cast]
   1142 |                         p->member.data=(void*)((packet[5]<<16)+(packet[7]<<8)+(packet[6]));
        |                                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• client.c:1164:15: warning: passing 'unsigned char *' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1164 |                 add_message(packet+1);
        |                             ^~~~~~~~
  

• client.c:1165:14: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1165 |                 n=2+strlen(packet+1);
        |                            ^~~~~~~~
  

• client.c:1180:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1180 |                         snprintf(txt,256, "Trying to change level to number %d",level_number);
        |                                  ^~~
  

• client.c:1181:16: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1181 |                         add_message(txt);
        |                                     ^~~
  

• client.c:1183:24: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1183 |                         if (!name){snprintf(error_message,1024,"Cannot find level number %d. Game terminated. Press ENTER.", level_number);send_quit();return -1;}
        |                                             ^~~~~~~~~~~~~
  

• client.c:1184:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1184 |                         snprintf(txt,256,"Changing level to \"%s\"",name);
        |                                  ^~~
  

• client.c:1186:16: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1186 |                         add_message(txt);
        |                                     ^~~
  

• client.c:1189:15: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1189 |                         if (strcmp(md5,packet+5))   /* MD5s differ */
        |                                    ^~~
  

• client.c:1189:19: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1189 |                         if (strcmp(md5,packet+5))   /* MD5s differ */
        |                                        ^~~~~~~~
  

• client.c:1192:14: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1192 |                                 snprintf(error_message,1024,"Invalid MD5 sum. Can't change level. Game terminated. Press ENTER.");
        |                                          ^~~~~~~~~~~~~
  

• client.c:1204:16: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1204 |                         send_packet(&p,1,(struct sockaddr *)(&server),my_id,0);
        |                                     ^~
  

• client.c:1210:20: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1210 |                 if (l<2)snprintf(error_message,1024,"Game terminated. Press ENTER.");
        |                                  ^~~~~~~~~~~~~
  

• client.c:1211:17: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1211 |                 else snprintf(error_message,1024,"Game terminated by %s. Press ENTER.",packet+1);
        |                               ^~~~~~~~~~~~~
  

• client.c:1229:13: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1229 |                         x=strlen(packet+l+9)+1;
        |                                  ^~~~~~~~~~
  

• client.c:1509:18: warning: passing 'char[8]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1509 |         if (find_sprite(txt,&sprite))
        |                         ^~~
  

• client.c:1514:12: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1514 |                 snprintf(msg,256,"Error: Can't find sprite \"%s\".\n",txt);
        |                          ^~~
  

• client.c:1515:9: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1515 |                 ERROR(msg);
        |                       ^~~
  

• client.c:1515:9: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   1515 |                 ERROR(msg);
        |                       ^~~
  

• client.c:1559:33: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1559 |                 print2screen((SCREEN_X-strlen(error_message)>>1),SCREEN_Y-1,9,error_message);
        |                                               ^~~~~~~~~~~~~
  

• client.c:1559:65: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1559 |                 print2screen((SCREEN_X-strlen(error_message)>>1),SCREEN_Y-1,9,error_message);
        |                                                                               ^~~~~~~~~~~~~
  

• client.c:1612:20: warning: passing 'char[8]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1612 |                         if (find_sprite(txt,&sprite))
        |                                         ^~~
  

• client.c:1621:20: warning: passing 'char[8]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1621 |                         if (find_sprite(txt,&sprite))
        |                                         ^~~
  

• client.c:1660:33: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1660 |                         if ((m=contact_server(*color,name)))
        |                                                      ^~~~
  

• client.c:1718:8: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
   1718 |         signum=signum;
        |         ~~~~~~^~~~~~~
  

• client.c:2030:15: warning: passing 'char[43]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2030 |         load_sprites(DATA_PATH GAME_SPRITES_FILE);
        |                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• client.c:2036:18: warning: passing 'char[4]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2036 |         if (find_sprite("hit",&hit_sprite)){ERROR("Error: Can't find sprite \"hit\".\n");EXIT(1);}
        |                         ^~~~~
  

• client.c:2037:18: warning: passing 'char[6]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2037 |         if (find_sprite("title",&title_sprite)){ERROR("Error: Can't find sprite \"title\".\n");EXIT(1);}
        |                         ^~~~~~~
  

• client.c:2038:18: warning: passing 'char[6]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2038 |         if (find_sprite("bulge",&bulge_sprite)){ERROR("Error: Can't find sprite \"bulge\".\n");EXIT(1);}
        |                         ^~~~~~~
  

• client.c:2041:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2041 |                 sprintf(txt,"shrapnel%d",a+1);
        |                         ^~~
  

• server.c:339:21: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    339 |         if (!(stream=fopen(filename,"rb"))){unsigned char msg[256];snprintf(msg,256,"Can't open file \"%s\"!\n",filename);ERROR(msg);EXIT(1);}
        |                            ^~~~~~~~
  

• server.c:339:70: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    339 |         if (!(stream=fopen(filename,"rb"))){unsigned char msg[256];snprintf(msg,256,"Can't open file \"%s\"!\n",filename);ERROR(msg);EXIT(1);}
        |                                                                             ^~~
  

• server.c:339:122: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    339 |         if (!(stream=fopen(filename,"rb"))){unsigned char msg[256];snprintf(msg,256,"Can't open file \"%s\"!\n",filename);ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:339:122: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    339 |         if (!(stream=fopen(filename,"rb"))){unsigned char msg[256];snprintf(msg,256,"Can't open file \"%s\"!\n",filename);ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:340:14: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    340 |         while(fgets(line,1024,stream))
        |                     ^~~~
  

• server.c:342:4: warning: assigning to 'char *' from 'unsigned char[1024]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    342 |                 p=line;
        |                  ^~~~~
  

• server.c:348:64: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    348 |                 if ((t=_convert_type(*p))<0){unsigned char msg[256];snprintf(msg,256,"Unknown object type '%c'.\n",*p);ERROR(msg);EXIT(1);}
        |                                                                              ^~~
  

• server.c:348:112: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    348 |                 if ((t=_convert_type(*p))<0){unsigned char msg[256];snprintf(msg,256,"Unknown object type '%c'.\n",*p);ERROR(msg);EXIT(1);}
        |                                                                                                                              ^~~
  

• server.c:348:112: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    348 |                 if ((t=_convert_type(*p))<0){unsigned char msg[256];snprintf(msg,256,"Unknown object type '%c'.\n",*p);ERROR(msg);EXIT(1);}
        |                                                                                                                              ^~~
  

• server.c:363:19: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    363 |                 if (find_sprite(name,&n)){unsigned char msg[256];snprintf(msg,256,"Unknown bitmap name \"%s\"!\n",name);ERROR(msg);EXIT(1);}
        |                                 ^~~~
  

• server.c:363:61: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    363 |                 if (find_sprite(name,&n)){unsigned char msg[256];snprintf(msg,256,"Unknown bitmap name \"%s\"!\n",name);ERROR(msg);EXIT(1);}
        |                                                                           ^~~
  

• server.c:363:113: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    363 |                 if (find_sprite(name,&n)){unsigned char msg[256];snprintf(msg,256,"Unknown bitmap name \"%s\"!\n",name);ERROR(msg);EXIT(1);}
        |                                                                                                                               ^~~
  

• server.c:363:113: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    363 |                 if (find_sprite(name,&n)){unsigned char msg[256];snprintf(msg,256,"Unknown bitmap name \"%s\"!\n",name);ERROR(msg);EXIT(1);}
        |                                                                                                                               ^~~
  

• server.c:376:10: warning: passing 'unsigned char *' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    376 |         sprintf(txt,"%d",*((unsigned char *)&ip));
        |                 ^~~
  

• server.c:378:22: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    378 |                 sprintf(txt+strlen(txt),".%d",((unsigned char *)&ip)[a]);
        |                                    ^~~
  

• server.c:378:11: warning: passing 'unsigned char *' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    378 |                 sprintf(txt+strlen(txt),".%d",((unsigned char *)&ip)[a]);
        |                         ^~~~~~~~~~~~~~~
  

• server.c:398:11: warning: passing 'unsigned char[64]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    398 |         snprintf(timestamp,64,"%2d.%2d.%d %02d:%02d:%02d  ",tm.tm_mday,tm.tm_mon+1,tm.tm_year+1900,tm.tm_hour,tm.tm_min,tm.tm_sec);
        |                  ^~~~~~~~~
  

• server.c:477:12: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    477 |                 snprintf(msg,256,"Error: Can't bind socket to port %d!\n",port);
        |                          ^~~
  

• server.c:478:9: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    478 |                 ERROR(msg);
        |                       ^~~
  

• server.c:478:9: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    478 |                 ERROR(msg);
        |                       ^~~
  

• server.c:501:10: warning: passing 'unsigned char[32]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    501 |         sprintf(txt,"hero%d",num);
        |                 ^~~
  

• server.c:542:12: warning: passing 'char[20]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    542 |                 {message("Not enough memory.\n",2);return 1;}
        |                          ^~~~~~~~~~~~~~~~~~~~~~
  

• server.c:543:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    543 |         cp->member.name=mem_alloc(strlen(name)+1);
        |                                          ^~~~
  

• server.c:545:25: warning: passing 'char[20]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    545 |                 {mem_free(cp);message("Not enough memory.\n",2);return 1;}
        |                                       ^~~~~~~~~~~~~~~~~~~~~~
  

• server.c:560:37: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    560 |         memcpy(cp->member.name,name,strlen(name)+1);
        |                                            ^~~~
  

• server.c:567:52: warning: passing 'char[16]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    567 |                 {mem_free(cp->member.name);mem_free(cp);message ("No such color.\n",1);return 1;}
        |                                                                  ^~~~~~~~~~~~~~~~~~
  

• server.c:570:51: warning: passing 'char[22]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    570 |                 {mem_free(cp->member.name);mem_free(cp);message("Can't create object.\n",1);return 1;}
        |                                                                 ^~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:889:12: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    889 |                 l=strlen((t[a])->name)+1;
        |                          ^~~~~~~~~~~~
  

• server.c:908:22: warning: passing 'unsigned char *' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    908 |         if (!name){snprintf(packet+1,256,"%s",msg);len=strlen(msg)+1+1;}
        |                             ^~~~~~~~
  

• server.c:908:56: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    908 |         if (!name){snprintf(packet+1,256,"%s",msg);len=strlen(msg)+1+1;}
        |                                                               ^~~
  

• server.c:909:17: warning: passing 'unsigned char *' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    909 |         else {snprintf(packet+1,256,"%s> %s",name,msg);len=strlen(name)+strlen(msg)+1+3;}
        |                        ^~~~~~~~
  

• server.c:909:60: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    909 |         else {snprintf(packet+1,256,"%s> %s",name,msg);len=strlen(name)+strlen(msg)+1+3;}
        |                                                                   ^~~~
  

• server.c:909:73: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    909 |         else {snprintf(packet+1,256,"%s> %s",name,msg);len=strlen(name)+strlen(msg)+1+3;}
        |                                                                                ^~~
  

• server.c:908:13: warning: 'snprintf' size argument is too large; destination buffer has size 255, but size argument is 256 [-Wfortify-source]
    908 |         if (!name){snprintf(packet+1,256,"%s",msg);len=strlen(msg)+1+1;}
        |                    ^
  

• server.c:909:8: warning: 'snprintf' size argument is too large; destination buffer has size 255, but size argument is 256 [-Wfortify-source]
    909 |         else {snprintf(packet+1,256,"%s> %s",name,msg);len=strlen(name)+strlen(msg)+1+3;}
        |               ^
  

• server.c:924:22: warning: passing 'unsigned char *' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    924 |         if (!name){snprintf(packet+1,255,"%s",msg);len=strlen(msg)+1+1;}
        |                             ^~~~~~~~
  

• server.c:924:56: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    924 |         if (!name){snprintf(packet+1,255,"%s",msg);len=strlen(msg)+1+1;}
        |                                                               ^~~
  

• server.c:925:17: warning: passing 'unsigned char *' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    925 |         else {snprintf(packet+1,255,"%s> %s",name,msg);len=strlen(name)+strlen(msg)+1+3;}
        |                        ^~~~~~~~
  

• server.c:925:60: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    925 |         else {snprintf(packet+1,255,"%s> %s",name,msg);len=strlen(name)+strlen(msg)+1+3;}
        |                                                                   ^~~~
  

• server.c:925:73: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    925 |         else {snprintf(packet+1,255,"%s> %s",name,msg);len=strlen(name)+strlen(msg)+1+3;}
        |                                                                                ^~~
  

• server.c:1155:4: warning: misleading indentation; statement is not part of the previous 'if' [-Wmisleading-indentation]
   1155 |                         return 0;
        |                         ^
  

• server.c:1172:82: warning: cast to 'void *' from smaller integer type 'int' [-Wint-to-void-pointer-cast]
   1172 |         o=new_obj(id,T_NOISE,NOISE_TTL,noise_sprite,0,0,int2double(x),int2double(y),0,0,(void *)(p->id));
        |                                                                                         ^~~~~~~~~~~~~~~
  

• server.c:1216:14: warning: passing 'char[30]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1216 |                                         message("Incompatible client version.\n",2);
        |                                                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:1225:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1225 |                                 snprintf(txt,256,"Request for player #%d (client version %d.%d) from %s.\n",n_players,maj,min,txt1);
        |                                          ^~~
  

• server.c:1229:14: warning: passing 'char[46]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1229 |                                         message("Incompatible client version. Player refused.\n",2);
        |                                                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:1235:16: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1235 |                                 if (strlen(packet+5) > MAX_NAME_LEN)
        |                                            ^~~~~~~~
  

• server.c:1237:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1237 |                                         snprintf(txt,256,"Name too long, shortening it to %i characters\n",MAX_NAME_LEN);
        |                                                  ^~~
  

• server.c:1244:14: warning: passing 'char[17]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1244 |                                         message("Player refused.\n",2);
        |                                                 ^~~~~~~~~~~~~~~~~~~
  

• server.c:1250:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1250 |                                 snprintf(txt,256,"Player #%d accepted, name \"%s\", address %s.\n",n_players,packet+5,txt1);
        |                                          ^~~
  

• server.c:1252:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1252 |                                 snprintf(txt,256,"%s entered the game.",packet+5);
        |                                          ^~~
  

• server.c:1273:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1273 |                                 snprintf(txt,256,"There'%s %d %s in the game.",active_players==1?"s":"re",active_players,active_players==1?"player":"players");
        |                                          ^~~
  

• server.c:1316:35: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1316 |                         memcpy(packet+1,p->name,strlen(p->name)+1);
        |                                                        ^~~~~~~
  

• server.c:1317:28: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1317 |                         sendall(packet,2+strlen(p->name),0);
        |                                                 ^~~~~~~
  

• server.c:1318:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1318 |                         snprintf(txt,256,"Game terminated by player \"%s\".\n",p->name);
        |                                  ^~~
  

• server.c:1330:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1330 |                         snprintf(txt,256,"%s left the game.\n",q->member.name);
        |                                  ^~~
  

• server.c:1334:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1334 |                         snprintf(txt,256,"%s left the game.",q->member.name);
        |                                  ^~~
  

• server.c:1360:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1360 |                         snprintf(txt,256,"%s> %s\n",q->member.name,packet+1);
        |                                  ^~~
  

• server.c:1365:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1365 |                         snprintf(txt,256,"Unknown packet: head=%d\n",*packet);
        |                                  ^~~
  

• server.c:1405:10: warning: passing 'unsigned char[32]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1405 |         sprintf(txt,"corpse%d",num);
        |                 ^~~
  

• server.c:1510:47: warning: passing 'char[17]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1510 |                                         send_message((struct player*)(p->data),0,"You got grenades");
        |                                                                                  ^~~~~~~~~~~~~~~~~~
  

• server.c:1511:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1511 |                                         snprintf(txt,256,"%s got grenades.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1534:47: warning: passing 'char[19]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1534 |                                         send_message((struct player*)(p->data),0,"You got a magazine");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~~
  

• server.c:1535:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1535 |                                         snprintf(txt,256,"%s got a magazine.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1558:47: warning: passing 'char[23]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1558 |                                         send_message((struct player*)(p->data),0,"You got shotgun shells");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:1559:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1559 |                                         snprintf(txt,256,"%s got shotgun shells.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1582:47: warning: passing 'char[19]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1582 |                                         send_message((struct player*)(p->data),0,"You got cartridges");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~~
  

• server.c:1583:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1583 |                                         snprintf(txt,256,"%s got cartridges.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1606:47: warning: passing 'char[21]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1606 |                                         send_message((struct player*)(p->data),0,"You got ammo for Uzi");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~~~~
  

• server.c:1607:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1607 |                                         snprintf(txt,256,"%s got Uzi ammo.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1631:47: warning: passing 'char[12]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1631 |                                         send_message((struct player*)(p->data),0,"You got Uzi");
        |                                                                                  ^~~~~~~~~~~~~
  

• server.c:1632:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1632 |                                         snprintf(txt,256,"%s got Uzi.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1656:47: warning: passing 'char[21]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1656 |                                         send_message((struct player*)(p->data),0,"You got sniper rifle");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~~~~
  

• server.c:1657:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1657 |                                         snprintf(txt,256,"%s got sniper rifle.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1681:47: warning: passing 'char[18]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1681 |                                         send_message((struct player*)(p->data),0,"You got a shotgun");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~
  

• server.c:1682:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1682 |                                         snprintf(txt,256,"%s got a shotgun.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1698:47: warning: passing 'char[26]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1698 |                                         send_message((struct player*)(p->data),0,"You got invisibility dope");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:1699:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1699 |                                         snprintf(txt,256,"%s got invisibility.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1715:47: warning: passing 'char[14]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1715 |                                         send_message((struct player*)(p->data),0,"You got armor");
        |                                                                                  ^~~~~~~~~~~~~~~
  

• server.c:1716:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1716 |                                         snprintf(txt,256,"%s got armor.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1732:47: warning: passing 'char[24]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1732 |                                         send_message((struct player*)(p->data),0,"You picked up a medikit");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:1733:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1733 |                                         snprintf(txt,256,"%s picked up a medikit.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1748:47: warning: passing 'char[20]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1748 |                                         send_message((struct player*)(p->data),0,"You killed yourself");
        |                                                                                  ^~~~~~~~~~~~~~~~~~~~~
  

• server.c:1749:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1749 |                                         snprintf(txt,256,"%s suicides",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1751:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1751 |                                         snprintf(txt,256,"%s suicides.\n",((struct player*)(p->data))->name);
        |                                                  ^~~
  

• server.c:1802:25: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
   1802 |                                         o=&((find_in_table((int)(obj->data)))->member);  /* owner of the bullet */
        |                                                            ^~~~~~~~~~~~~~~~
  

• server.c:1807:48: warning: passing 'char[20]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1807 |                                                 send_message((struct player*)(o->data),0,"You killed yourself");
        |                                                                                          ^~~~~~~~~~~~~~~~~~~~~
  

• server.c:1808:16: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1808 |                                                 snprintf(txt,256,"%s suicides",((struct player*)(o->data))->name);
        |                                                          ^~~
  

• server.c:1810:16: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1810 |                                                 snprintf(txt,256,"%s suicides.\n",((struct player*)(o->data))->name);
        |                                                          ^~~
  

• server.c:1816:16: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1816 |                                                 snprintf(txt,256,"%s killed %s.",((struct player*)(o->data))->name,((struct player*)(p->data))->name);
        |                                                          ^~~
  

• server.c:1818:16: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1818 |                                                 snprintf(txt,256,"%s killed you",((struct player*)(o->data))->name);
        |                                                          ^~~
  

• server.c:1820:16: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1820 |                                                 snprintf(txt,256,"You killed %s",((struct player*)(p->data))->name);
        |                                                          ^~~
  

• server.c:1822:16: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1822 |                                                 snprintf(txt,256,"%s killed %s.\n",((struct player*)(o->data))->name,((struct player*)(p->data))->name);
        |                                                          ^~~
  

• server.c:1927:21: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
   1927 |                                 q=find_player(0,(int)(p->next->member.data));
        |                                                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:1954:6: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   1954 |                                         (void *)(p->next->member.id)); 
        |                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:2168:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2168 |         snprintf(txt,256,"Signal %d caught.\n",sig_num);
        |                  ^~~
  

• server.c:2253:21: warning: passing 'char[11]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2253 |                 {send_message(q,0,"No weapon.");return;}
        |                                   ^~~~~~~~~~~~
  

• server.c:2255:21: warning: passing 'char[17]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2255 |                 {send_message(q,0,"Not enough ammo.");return;}
        |                                   ^~~~~~~~~~~~~~~~~~
  

• server.c:2257:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2257 |         snprintf(txt,256,"%s takes %s.\n",q->name,weapon[w].name);
        |                  ^~~
  

• server.c:2293:4: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2293 |                         (void *)(q->obj->id)); 
        |                         ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2307:4: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2307 |                         (void *)(q->obj->id)); 
        |                         ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2321:4: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2321 |                         (void *)(q->obj->id)); 
        |                         ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2335:4: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2335 |                         (void *)(q->obj->id)); 
        |                         ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2349:4: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2349 |                         (void *)(q->obj->id)); 
        |                         ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2363:4: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2363 |                         (void *)(q->obj->id)); 
        |                         ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2377:4: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2377 |                         (void *)(q->obj->id)); 
        |                         ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2396:5: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2396 |                                 (void *)(q->obj->id)); 
        |                                 ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2410:5: warning: cast to 'void *' from smaller integer type 'unsigned int' [-Wint-to-void-pointer-cast]
   2410 |                                 (void *)(q->obj->id)); 
        |                                 ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2497:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2497 |                         snprintf(txt,256,"%s not responding. Kicked out of the game.\n",p->next->member.name);
        |                                  ^~~
  

• server.c:2501:13: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2501 |                         snprintf(txt,256,"%s was kicked out of the game.",p->next->member.name);
        |                                  ^~~
  

• server.c:2643:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2643 |         snprintf(txt,256,"Running 0verkill server version %d.%d\n",VERSION_MAJOR,VERSION_MINOR);
        |                  ^~~
  

• server.c:2649:10: warning: passing 'char[17]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2649 |         message("Initialization.\n",2);
        |                 ^~~~~~~~~~~~~~~~~~~
  

• server.c:2667:10: warning: passing 'char[18]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2667 |         message("Loading sprites.\n",2);
        |                 ^~~~~~~~~~~~~~~~~~~~
  

• server.c:2668:15: warning: passing 'char[43]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2668 |         load_sprites(DATA_PATH GAME_SPRITES_FILE); /* players, corpses, bullets, ... */
        |                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:2669:18: warning: passing 'char[7]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2669 |         if (find_sprite("bullet",&bullet_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"bullet\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~~
  

• server.c:2669:76: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2669 |         if (find_sprite("bullet",&bullet_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"bullet\".\n");ERROR(msg);EXIT(1);}
        |                                                                                   ^~~
  

• server.c:2669:125: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2669 |         if (find_sprite("bullet",&bullet_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"bullet\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                    ^~~
  

• server.c:2669:125: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2669 |         if (find_sprite("bullet",&bullet_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"bullet\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                    ^~~
  

• server.c:2670:18: warning: passing 'char[5]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2670 |         if (find_sprite("slug",&slug_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"slug\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~
  

• server.c:2670:72: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2670 |         if (find_sprite("slug",&slug_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"slug\".\n");ERROR(msg);EXIT(1);}
        |                                                                               ^~~
  

• server.c:2670:119: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2670 |         if (find_sprite("slug",&slug_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"slug\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                              ^~~
  

• server.c:2670:119: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2670 |         if (find_sprite("slug",&slug_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"slug\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                              ^~~
  

• server.c:2671:18: warning: passing 'char[6]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2671 |         if (find_sprite("shell",&shell_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"shell\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~
  

• server.c:2671:74: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2671 |         if (find_sprite("shell",&shell_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"shell\".\n");ERROR(msg);EXIT(1);}
        |                                                                                 ^~~
  

• server.c:2671:122: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2671 |         if (find_sprite("shell",&shell_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"shell\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2671:122: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2671 |         if (find_sprite("shell",&shell_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"shell\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2672:18: warning: passing 'char[7]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2672 |         if (find_sprite("sshell",&shotgun_shell_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"sshell\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~~
  

• server.c:2672:83: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2672 |         if (find_sprite("sshell",&shotgun_shell_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"sshell\".\n");ERROR(msg);EXIT(1);}
        |                                                                                          ^~~
  

• server.c:2672:132: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2672 |         if (find_sprite("sshell",&shotgun_shell_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"sshell\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                           ^~~
  

• server.c:2672:132: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2672 |         if (find_sprite("sshell",&shotgun_shell_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"sshell\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                           ^~~
  

• server.c:2673:18: warning: passing 'char[8]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2673 |         if (find_sprite("grenade",&grenade_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"grenade\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~~~
  

• server.c:2673:78: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2673 |         if (find_sprite("grenade",&grenade_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"grenade\".\n");ERROR(msg);EXIT(1);}
        |                                                                                     ^~~
  

• server.c:2673:128: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2673 |         if (find_sprite("grenade",&grenade_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"grenade\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                       ^~~
  

• server.c:2673:128: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2673 |         if (find_sprite("grenade",&grenade_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"grenade\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                       ^~~
  

• server.c:2674:18: warning: passing 'char[6]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2674 |         if (find_sprite("mess1",&mess1_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess1\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~
  

• server.c:2674:74: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2674 |         if (find_sprite("mess1",&mess1_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess1\".\n");ERROR(msg);EXIT(1);}
        |                                                                                 ^~~
  

• server.c:2674:122: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2674 |         if (find_sprite("mess1",&mess1_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess1\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2674:122: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2674 |         if (find_sprite("mess1",&mess1_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess1\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2675:18: warning: passing 'char[6]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2675 |         if (find_sprite("mess2",&mess2_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess2\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~
  

• server.c:2675:74: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2675 |         if (find_sprite("mess2",&mess2_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess2\".\n");ERROR(msg);EXIT(1);}
        |                                                                                 ^~~
  

• server.c:2675:122: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2675 |         if (find_sprite("mess2",&mess2_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess2\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2675:122: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2675 |         if (find_sprite("mess2",&mess2_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess2\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2676:18: warning: passing 'char[6]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2676 |         if (find_sprite("mess3",&mess3_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess3\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~
  

• server.c:2676:74: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2676 |         if (find_sprite("mess3",&mess3_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess3\".\n");ERROR(msg);EXIT(1);}
        |                                                                                 ^~~
  

• server.c:2676:122: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2676 |         if (find_sprite("mess3",&mess3_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess3\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2676:122: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2676 |         if (find_sprite("mess3",&mess3_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess3\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2677:18: warning: passing 'char[6]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2677 |         if (find_sprite("mess4",&mess4_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess4\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~
  

• server.c:2677:74: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2677 |         if (find_sprite("mess4",&mess4_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess4\".\n");ERROR(msg);EXIT(1);}
        |                                                                                 ^~~
  

• server.c:2677:122: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2677 |         if (find_sprite("mess4",&mess4_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess4\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2677:122: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2677 |         if (find_sprite("mess4",&mess4_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"mess4\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2678:18: warning: passing 'char[6]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2678 |         if (find_sprite("noise",&noise_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"noise\".\n");ERROR(msg);EXIT(1);}
        |                         ^~~~~~~
  

• server.c:2678:74: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2678 |         if (find_sprite("noise",&noise_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"noise\".\n");ERROR(msg);EXIT(1);}
        |                                                                                 ^~~
  

• server.c:2678:122: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2678 |         if (find_sprite("noise",&noise_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"noise\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2678:122: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   2678 |         if (find_sprite("noise",&noise_sprite)){unsigned char msg[256];snprintf(msg,256,"Can't find sprite \"noise\".\n");ERROR(msg);EXIT(1);}
        |                                                                                                                                 ^~~
  

• server.c:2681:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• server.c:2682:77: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• ./error.h:76:12: warning: passing 'char[15]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• server.c:2682:126: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• ./error.h:86:12: warning: passing 'char[22]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• ./error.h:94:9: warning: passing 'char[46]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• server.c:2682:126: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
  

• ./error.h:100:75: warning: explicitly assigning value of variable of type 'unsigned char *' to itself [-Wself-assign]
  

• ./error.h:101:76: warning: explicitly assigning value of variable of type 'unsigned char *' to itself [-Wself-assign]
  

• ./error.h:101:81: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
  

• ./error.h:103:91: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
  

• server.c:2687:96: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
  

• ./error.h:104:72: warning: explicitly assigning value of variable of type 'void *' to itself [-Wself-assign]
  

• server.c:2688:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2688 |         snprintf(txt,256,"Loading level \"%s\"....\n",LEVEL);
        |                  ^~~
  

• server.c:2690:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2690 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,LEVEL_SPRITES_SUFFIX);
        |                  ^~~
  

• server.c:2691:10: warning: passing 'char[25]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2691 |         message("Loading level graphics.\n",2);
        |                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:2693:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2693 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,STATIC_DATA_SUFFIX);
        |                  ^~~
  

• data.c:77:3: warning: initializing 'unsigned char *' with an expression of type 'char[9]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• server.c:2694:10: warning: passing 'char[20]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• data.c:78:3: warning: initializing 'unsigned char *' with an expression of type 'char[8]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• data.c:79:3: warning: initializing 'unsigned char *' with an expression of type 'char[4]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• server.c:2696:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• data.c:80:3: warning: initializing 'unsigned char *' with an expression of type 'char[6]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• data.c:81:3: warning: initializing 'unsigned char *' with an expression of type 'char[9]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• server.c:2697:10: warning: passing 'char[24]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• server.c:2701:10: warning: passing 'char[22]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2701 |         message("Initializing socket.\n",2);
        |                 ^~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:2704:10: warning: passing 'char[29]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2704 |         message("Installing signal handlers.\n",2);
        |                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• server.c:2714:10: warning: passing 'char[15]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2714 |         message("Game started.\n",2);
        |                 ^~~~~~~~~~~~~~~~~
  

• server.c:2741:11: warning: passing 'char[7]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2741 |                 message("Sleep\n",2);
        |                         ^~~~~~~~~
  

• data.c:126:15: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• server.c:2748:11: warning: passing 'char[8]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
  

• data.c:126:34: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    126 |   if (!strcmp(sprite_names[*num],name))return 0;
        |                                  ^~~~
  

• data.c:196:21: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    196 |  if (!(stream=fopen(filename,"rb")))
        |                     ^~~~~~~~
  

• data.c:200:8: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    200 |         ERROR(msg);
        |               ^~~
  

• data.c:215:8: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    215 |         ERROR(msg);
        |               ^~~
  

• data.c:223:19: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    223 |   if (find_sprite(name,&n))
        |                   ^~~~
  

• data.c:227:8: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    227 |         ERROR(msg);
        |               ^~~
  

• data.c:244:15: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    244 |  stream=fopen(filename,"rb");
        |               ^~~~~~~~
  

• data.c:249:8: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    249 |         ERROR(msg);
        |               ^~~
  

• data.c:265:28: warning: assigning to 'unsigned char *' from 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    265 |   sprite_names[n_sprites-1]=(char *)mem_alloc(l+1);
        |                            ^~~~~~~~~~~~~~~~~~~~~~~
  

• data.c:271:15: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    271 |   load_sprite(q,sprites+(n_sprites-1));
        |               ^
  

• data.c:308:15: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    308 |                 if (!(fgets(txt,1024,f)))return NULL;
        |                             ^~~
  

• data.c:311:18: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    311 |                 if (txt[strlen(txt)-1]==10)txt[strlen(txt)-1]=0;
        |                                ^~~
  

• data.c:311:41: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    311 |                 if (txt[strlen(txt)-1]==10)txt[strlen(txt)-1]=0;
        |                                                       ^~~
  

• data.c:312:18: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    312 |                 if (txt[strlen(txt)-1]==13)txt[strlen(txt)-1]=0;
        |                                ^~~
  

• data.c:312:41: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    312 |                 if (txt[strlen(txt)-1]==13)txt[strlen(txt)-1]=0;
        |                                                       ^~~
  

• data.c:314:14: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    314 |                 if (strlen(txt))a++;
        |                            ^~~
  

• data.c:319:11: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    319 |         a=strlen(txt);
        |                  ^~~
  

• data.c:323:14: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    323 |         if (!strlen(retval)){mem_free(retval);return NULL;}
        |                     ^~~~~~
  

• data.c:591:12: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    591 |         q=MD5File(filename,NULL);
        |                   ^~~~~~~~
  

• data.c:591:3: warning: assigning to 'unsigned char *' from 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    591 |         q=MD5File(filename,NULL);
        |          ^~~~~~~~~~~~~~~~~~~~~~~
  

• data.c:592:11: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    592 |         a=strlen(q);
        |                  ^
  

• data.c:614:3: warning: assigning to 'char *' from 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    614 |         q=load_level(level_num);
        |          ^~~~~~~~~~~~~~~~~~~~~~
  

• data.c:617:17: warning: passing 'char[41]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    617 |         if (!__add_md5(DATA_PATH LEVEL_FILE,&len,&result)){mem_free(result);return NULL;}
        |                        ^~~~~~~~~~~~~~~~~~~~
  

• data.c:619:11: warning: passing 'unsigned char[2048]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    619 |         snprintf(p,2048,"%s%s%s",DATA_PATH,q,LEVEL_SPRITES_SUFFIX);
        |                  ^
  

• data.c:622:11: warning: passing 'unsigned char[2048]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    622 |         snprintf(p,2048,"%s%s%s",DATA_PATH,q,STATIC_DATA_SUFFIX);
        |                  ^
  

• data.c:625:11: warning: passing 'unsigned char[2048]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    625 |         snprintf(p,2048,"%s%s%s",DATA_PATH,q,DYNAMIC_DATA_SUFFIX);
        |                  ^
  

• data.c:628:11: warning: passing 'unsigned char[2048]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    628 |         snprintf(p,2048,"%s%s%s",DATA_PATH,q,LEVEL_SPRITES_SUFFIX);
        |                  ^
  

• data.c:634:11: warning: passing 'unsigned char[2048]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    634 |                 f=fopen(p,"r");
        |                         ^
  

• data.c:636:16: warning: passing 'unsigned char[2048]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    636 |                 while (fgets(p,2048,f))
        |                              ^
  

• data.c:638:17: warning: passing 'unsigned char[2048]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    638 |                         if (p[strlen(p)-1]==13)p[strlen(p)-1]=0;
        |                                      ^
  

• data.c:638:36: warning: passing 'unsigned char[2048]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    638 |                         if (p[strlen(p)-1]==13)p[strlen(p)-1]=0;
        |                                                         ^
  

• data.c:639:17: warning: passing 'unsigned char[2048]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    639 |                         if (p[strlen(p)-1]==10)p[strlen(p)-1]=0;
        |                                      ^
  

• data.c:639:36: warning: passing 'unsigned char[2048]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    639 |                         if (p[strlen(p)-1]==10)p[strlen(p)-1]=0;
        |                                                         ^
  

• data.c:641:5: warning: assigning to 'char *' from 'unsigned char[2048]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    641 |                         q=p;
        |                          ^~
  

• data.c:646:19: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    646 |                         if (!__add_md5(q,&len,&result)){mem_free(result);return NULL;}
        |                                        ^
  

• data.c:653:9: warning: returning 'char *' from a function with result type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    653 |         return q;
        |                ^
  

• sprite.c:190:16: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    190 |         if (!(f=fopen(filename,"rb")))
        |                       ^~~~~~~~
  

• sprite.c:194:16: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    194 |         if (!(f=fopen(filename,"rb")))
        |                       ^~~~~~~~
  

• sprite.c:198:16: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    198 |         if (!(f=fopen(filename,"rb")))
        |                       ^~~~~~~~
  

• sprite.c:201:12: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    201 |                 snprintf(msg,256,"Error opening file \"%s\"!\n",filename);
        |                          ^~~
  

• sprite.c:202:9: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    202 |                 ERROR(msg);
        |                       ^~~
  

• sprite.c:202:9: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    202 |                 ERROR(msg);
        |                       ^~~
  

• sprite.c:205:14: warning: passing 'unsigned char[8192]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    205 |         while(fgets(buffer,8191,f))
        |                     ^~~~~~
  

• sprite.c:207:12: warning: passing 'unsigned char[8192]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    207 |                 x=strlen(buffer);
        |                          ^~~~~~
  

• sprite.c:221:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    221 |                                 snprintf(msg,256,"Syntax error in file \"%s\".\n",filename);
        |                                          ^~~
  

• sprite.c:222:11: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    222 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:222:11: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    222 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:237:33: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    237 |                         s->positions[CURP].xo=strtol(buffer+1,&p,0);
        |                                                      ^~~~~~~~
  

• sprite.c:245:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    245 |                                 snprintf(msg,256,"Syntax error in file \"%s\".\n",filename);
        |                                          ^~~
  

• sprite.c:246:11: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    246 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:246:11: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    246 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:258:46: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    258 |                         s->positions[CURP].lines[CURL].len=strlen(buffer+1);
        |                                                                   ^~~~~~~~
  

• sprite.c:273:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    273 |                                 snprintf(msg,256,"Syntax error in file \"%s\".\n",filename);
        |                                          ^~~
  

• sprite.c:274:11: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    274 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:274:11: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    274 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:291:13: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    291 |                         x=strlen(buffer+1);
        |                                  ^~~~~~~~
  

• sprite.c:302:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    302 |                                 snprintf(msg,256,"Syntax error in file \"%s\".\n",filename);
        |                                          ^~~
  

• sprite.c:303:11: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    303 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:303:11: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    303 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:307:9: warning: assigning to 'char *' from 'unsigned char[8192]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    307 |                         for(q=buffer,p=buffer+1;*q&&*q!=10;*q==','?p=q+1:0)
        |                              ^~~~~~~
  

• sprite.c:307:18: warning: assigning to 'char *' from 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    307 |                         for(q=buffer,p=buffer+1;*q&&*q!=10;*q==','?p=q+1:0)
        |                                       ^~~~~~~~~
  

• sprite.c:314:15: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    314 |                                         snprintf(txt,256,"Error loading sprite \"%s\". Undefined position %d.\n",filename,x);
        |                                                  ^~~
  

• sprite.c:315:12: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    315 |                                         ERROR(txt);
        |                                               ^~~
  

• sprite.c:315:12: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    315 |                                         ERROR(txt);
        |                                               ^~~
  

• sprite.c:333:14: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    333 |                                 snprintf(msg,256,"Syntax error in file \"%s\"!\n",filename);
        |                                          ^~~
  

• sprite.c:334:11: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    334 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:334:11: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    334 |                                 ERROR(msg);
        |                                       ^~~
  

• sprite.c:343:12: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    343 |                 snprintf(msg,256,"Unexpected end of file in \"%s\".\n",filename);
        |                          ^~~
  

• sprite.c:344:9: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    344 |                 ERROR(msg);
        |                       ^~~
  

• sprite.c:344:9: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    344 |                 ERROR(msg);
        |                       ^~~
  

• console.c:209:2: warning: 'snprintf' size argument is too large; destination buffer has size 8, but size argument is 16 [-Wfortify-source]
    209 |         snprintf(txt,16,"\033[%dm",30+(a&7));
        |         ^
  

• net.c:86:41: warning: passing 'int *' to parameter of type 'socklen_t *' (aka 'unsigned int *') converts between pointers to integer types with different sign [-Wpointer-sign]
     86 |         retval=recvfrom(fd,p,max_len+12,0,addr,addr_len);
        |                                                ^~~~~~~~
  

• ./error.h:26:23: warning: call to undeclared library function 'memset' with type 'void *(void *, int, unsigned long)'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
     26 |         if ((p = malloc(x))) memset(p, 0, x);
        |                              ^
  

• error.c:82:3: warning: explicitly assigning value of variable of type 'void *' to itself [-Wself-assign]
     82 |         p=p;
        |         ~^~
  

• error.c:126:19: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    126 |         vfprintf(stderr, m, l);
        |                          ^
  

• error.c:147:10: warning: passing 'unsigned char[4096]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    147 |         sprintf(errbuf, "\033[1mINTERNAL ERROR\033[0m at %s:%d: ", errfile, errline);
        |                 ^~~~~~
  

• error.c:148:9: warning: passing 'unsigned char[4096]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    148 |         strcat(errbuf, m);
        |                ^~~~~~
  

• error.c:148:17: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    148 |         strcat(errbuf, m);
        |                        ^
  

• error.c:157:10: warning: passing 'unsigned char[4096]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    157 |         sprintf(errbuf, "DEBUG MESSAGE at %s:%d: ", errfile, errline);
        |                 ^~~~~~
  

• error.c:158:9: warning: passing 'unsigned char[4096]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    158 |         strcat(errbuf, m);
        |                ^~~~~~
  

• error.c:158:17: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    158 |         strcat(errbuf, m);
        |                        ^
  

• xinterface.c:101:3: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    101 |         w=w;h=h;
        |         ~^~
  

• xinterface.c:101:7: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    101 |         w=w;h=h;
        |             ~^~
  

• xinterface.c:368:6: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    368 |         type=type;
        |         ~~~~^~~~~
  

• xkbd.c:178:7: warning: variable 'nbytes' set but not used [-Wunused-but-set-variable]
    178 |         int  nbytes;
        |              ^
  

• editor.c:127:9: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    127 |                 ERROR(msg);
        |                       ^~~
  

• editor.c:144:19: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    144 |                 if (find_sprite(name,&n))
        |                                 ^~~~
  

• editor.c:148:10: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    148 |                         ERROR(msg);
        |                               ^~~
  

• editor.c:271:11: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    271 |         snprintf(txt,1024,"%s%s%s",DATA_PATH,LEVEL,STATIC_DATA_SUFFIX);
        |                  ^~~
  

• editor.c:272:13: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    272 |         data=fopen(txt,"w");
        |                    ^~~
  

• editor.c:276:12: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    276 |                 snprintf(msg,256,"Can't create file \"%s\"\n",txt);
        |                          ^~~
  

• editor.c:277:9: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    277 |                 ERROR(msg);
        |                       ^~~
  

• editor.c:277:9: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    277 |                 ERROR(msg);
        |                       ^~~
  

• editor.c:281:11: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    281 |         snprintf(txt,1024,"%s%s%s",DATA_PATH,LEVEL,DYNAMIC_DATA_SUFFIX);
        |                  ^~~
  

• editor.c:283:16: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    283 |         dynamic=fopen(txt,"w");
        |                       ^~~
  

• editor.c:287:12: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    287 |                 snprintf(msg,256,"Can't create file \"%s\"\n",txt);
        |                          ^~~
  

• editor.c:288:9: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    288 |                 ERROR(msg);
        |                       ^~~
  

• editor.c:288:9: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    288 |                 ERROR(msg);
        |                       ^~~
  

• editor.c:296:11: warning: passing 'unsigned char[1024]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    296 |                 sprintf(txt,"%s %c %d %d\n",sprite_names[O.sprite],O.type,O.x,O.y);
        |                         ^~~
  

• editor.c:304:10: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    304 |                         fputs(txt,data);
        |                               ^~~
  

• editor.c:308:10: warning: passing 'unsigned char[1024]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    308 |                         fputs(txt,dynamic);
        |                               ^~~
  

• editor.c:321:8: warning: explicitly assigning value of variable of type 'int' to itself [-Wself-assign]
    321 |         signum=signum;
        |         ~~~~~~^~~~~~~
  

• editor.c:412:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    412 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,LEVEL_SPRITES_SUFFIX);
        |                  ^~~
  

• editor.c:414:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    414 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,STATIC_DATA_SUFFIX);
        |                  ^~~
  

• editor.c:415:12: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    415 |         load_room(txt);
        |                   ^~~
  

• editor.c:416:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    416 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,DYNAMIC_DATA_SUFFIX);
        |                  ^~~
  

• editor.c:418:12: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    418 |         load_room(txt);
        |                   ^~~
  

• editor.c:448:10: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    448 |         sprintf(txt,"% 4d   ",x+xoffset);
        |                 ^~~
  

• editor.c:450:10: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    450 |         c_print(txt);
        |                 ^~~
  

• editor.c:453:10: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    453 |         sprintf(txt,"% 4d   ",y+yoffset);
        |                 ^~~
  

• editor.c:455:10: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    455 |         c_print(txt);
        |                 ^~~
  

• editor.c:458:10: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    458 |         sprintf(txt,"%-.20s   ",obj?(char*)(sprite_names[obj->sprite]):"----");
        |                 ^~~
  

• editor.c:460:10: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    460 |         c_print(txt);
        |                 ^~~
  

• editor.c:463:10: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    463 |         sprintf(txt,"%c   ",obj?obj->type:'-');
        |                 ^~~
  

• editor.c:465:10: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    465 |         c_print(txt);
        |                 ^~~
  

• avi.c:60:14: warning: passing 'unsigned char[16384]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     60 |         if (!(fgets(line,sizeof(line),f))){
        |                     ^~~~
  

• avi.c:70:16: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     70 |         retval=strtol(lptr,(char **)&lptr,0);
        |                       ^~~~
  

• avi.c:184:10: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    184 |         f=fopen(filename,"r");
        |                 ^~~~~~~~
  

• avi.c:260:10: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    260 |         f=fopen(filename,"w");
        |                 ^~~~~~~~
  

• avi.c:393:11: warning: passing 'unsigned char[32]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    393 |         snprintf(txt,32,"%d",cursor_pos);
        |                  ^~~
  

• avi.c:394:31: warning: passing 'unsigned char[32]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    394 |         print2screen(x,SCREEN_Y-2,11,txt);x+=strlen(txt)+2;
        |                                      ^~~
  

• avi.c:394:46: warning: passing 'unsigned char[32]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    394 |         print2screen(x,SCREEN_Y-2,11,txt);x+=strlen(txt)+2;
        |                                                     ^~~
  

• avi.c:396:11: warning: passing 'unsigned char[32]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    396 |         snprintf(txt,32,"% 5d",cursor_x);
        |                  ^~~
  

• avi.c:397:31: warning: passing 'unsigned char[32]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    397 |         print2screen(x,SCREEN_Y-2,11,txt);x+=5;
        |                                      ^~~
  

• avi.c:399:11: warning: passing 'unsigned char[32]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    399 |         snprintf(txt,32,"% 5d",cursor_y);
        |                  ^~~
  

• avi.c:400:31: warning: passing 'unsigned char[32]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    400 |         print2screen(x,SCREEN_Y-2,11,txt);x+=5;
        |                                      ^~~
  

• avi.c:711:11: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    711 |         load_avi(argv[1]);
        |                  ^~~~~~~
  

• avi.c:713:11: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    713 |         save_avi(argv[1]);
        |                  ^~~~~~~
  

• bot.c:120:2: warning: initializing 'unsigned char *' with an expression of type 'char[11]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    120 |         "Terminator",
        |         ^~~~~~~~~~~~
  

• bot.c:121:2: warning: initializing 'unsigned char *' with an expression of type 'char[16]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    121 |         "Jack The Ripper",
        |         ^~~~~~~~~~~~~~~~~
  

• bot.c:122:2: warning: initializing 'unsigned char *' with an expression of type 'char[6]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    122 |         "Rambo",
        |         ^~~~~~~
  

• bot.c:123:2: warning: initializing 'unsigned char *' with an expression of type 'char[10]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    123 |         "Exhumator",
        |         ^~~~~~~~~~~
  

• bot.c:124:2: warning: initializing 'unsigned char *' with an expression of type 'char[9]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    124 |         "Assassin",
        |         ^~~~~~~~~~
  

• bot.c:125:2: warning: initializing 'unsigned char *' with an expression of type 'char[7]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    125 |         "Arnold",
        |         ^~~~~~~~
  

• bot.c:126:2: warning: initializing 'unsigned char *' with an expression of type 'char[12]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    126 |         "Necromancer",
        |         ^~~~~~~~~~~~~
  

• bot.c:127:2: warning: initializing 'unsigned char *' with an expression of type 'char[9]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    127 |         "Predator",
        |         ^~~~~~~~~~
  

• bot.c:128:2: warning: initializing 'unsigned char *' with an expression of type 'char[6]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    128 |         "Rocky",
        |         ^~~~~~~
  

• bot.c:129:2: warning: initializing 'unsigned char *' with an expression of type 'char[10]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    129 |         "Harvester",
        |         ^~~~~~~~~~~
  

• bot.c:130:2: warning: initializing 'unsigned char *' with an expression of type 'char[6]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    130 |         "Lamer",
        |         ^~~~~~~
  

• bot.c:131:2: warning: initializing 'unsigned char *' with an expression of type 'char[7]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    131 |         "Killme",
        |         ^~~~~~~~
  

• bot.c:132:2: warning: initializing 'unsigned char *' with an expression of type 'char[7]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    132 |         "Looser",
        |         ^~~~~~~~
  

• bot.c:133:2: warning: initializing 'unsigned char *' with an expression of type 'char[8]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    133 |         "Krueger",
        |         ^~~~~~~~~
  

• bot.c:134:2: warning: initializing 'unsigned char *' with an expression of type 'char[14]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    134 |         "I'll kill you",
        |         ^~~~~~~~~~~~~~~
  

• bot.c:135:2: warning: initializing 'unsigned char *' with an expression of type 'char[10]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    135 |         "Zombieman",
        |         ^~~~~~~~~~~
  

• bot.c:136:2: warning: initializing 'unsigned char *' with an expression of type 'char[11]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    136 |         "Hellraiser",
        |         ^~~~~~~~~~~~
  

• bot.c:137:2: warning: initializing 'unsigned char *' with an expression of type 'char[7]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    137 |         "Eraser"
        |         ^~~~~~~~
  

• bot.c:251:15: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    251 |         int l=strlen(name)+1;
        |                      ^~~~
  

• bot.c:502:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    502 |         snprintf(txt,256,"Loading level \"%s\".\n",LEVEL);
        |                  ^~~
  

• bot.c:503:8: warning: passing 'unsigned char[256]' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    503 |         ERROR(txt);
        |               ^~~
  

• bot.c:503:8: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
    503 |         ERROR(txt);
        |               ^~~
  

• bot.c:504:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    504 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,LEVEL_SPRITES_SUFFIX);
        |                  ^~~
  

• bot.c:506:11: warning: passing 'unsigned char[256]' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    506 |         snprintf(txt,256,"%s%s%s",DATA_PATH,LEVEL,STATIC_DATA_SUFFIX);
        |                  ^~~
  

• bot.c:837:19: warning: cast to 'void *' from smaller integer type 'int' [-Wint-to-void-pointer-cast]
    837 |                         p->member.data=(void*)((packet[5]<<16)+(packet[7]<<8)+(packet[6]));
        |                                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• bot.c:859:14: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    859 |                 n=2+strlen(packet+1);
        |                            ^~~~~~~~
  

• bot.c:865:14: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    865 |                 n=2+strlen(packet+1);
        |                            ^~~~~~~~
  

• bot.c:874:13: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    874 |                         x=strlen(packet+l+9)+1;
        |                                  ^~~~~~~~~~
  

• bot.c:929:15: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    929 |                         if (strcmp(md5,packet+5))   /* MD5s differ */
        |                                    ^~~
  

• bot.c:929:19: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    929 |                         if (strcmp(md5,packet+5))   /* MD5s differ */
        |                                        ^~~~~~~~
  

• bot.c:943:16: warning: passing 'char *' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    943 |                         send_packet(&p,1,(struct sockaddr *)(&server),my_id,0);
        |                                     ^~
  

• bot.c:1029:8: warning: assigning to 'unsigned char *' from 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1029 |                         host=optarg;
        |                             ^~~~~~~
  

• bot.c:1107:15: warning: passing 'char[43]' to parameter of type 'unsigned char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1107 |         load_sprites(DATA_PATH GAME_SPRITES_FILE);
        |                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• bot.c:1122:21: warning: passing 'unsigned char *' to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1122 |         if ((m=find_server(host,port))){ERROR(m);EXIT(1);}
        |                            ^~~~
  

• bot.c:1122:8: warning: assigning to 'unsigned char *' from 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1122 |         if ((m=find_server(host,port))){ERROR(m);EXIT(1);}
        |               ^~~~~~~~~~~~~~~~~~~~~~~
  

• bot.c:1122:40: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1122 |         if ((m=find_server(host,port))){ERROR(m);EXIT(1);}
        |                                               ^
  

• bot.c:1122:40: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   1122 |         if ((m=find_server(host,port))){ERROR(m);EXIT(1);}
        |                                               ^
  

• bot.c:1124:8: warning: assigning to 'unsigned char *' from 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1124 |         if ((m=init_socket())){ERROR(m);EXIT(1);}
        |               ^~~~~~~~~~~~~~
  

• bot.c:1124:31: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1124 |         if ((m=init_socket())){ERROR(m);EXIT(1);}
        |                                      ^
  

• bot.c:1124:31: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   1124 |         if ((m=init_socket())){ERROR(m);EXIT(1);}
        |                                      ^
  

• bot.c:1127:8: warning: assigning to 'unsigned char *' from 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1127 |         if ((m=contact_server(color,select_name()))){ERROR(m);EXIT(1);}
        |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• bot.c:1127:53: warning: passing 'unsigned char *' to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1127 |         if ((m=contact_server(color,select_name()))){ERROR(m);EXIT(1);}
        |                                                            ^
  

• bot.c:1127:53: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
   1127 |         if ((m=contact_server(color,select_name()))){ERROR(m);EXIT(1);}
        |                                                            ^