stbuehler/sdlbomber
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add clang-format config and format everything

Browse Source
This commit is contained in:
Stefan Bühler 2021-09-15 19:20:06 +02:00
parent 187ec1a68e
commit 56458af5fc
20 changed files with 2193 additions and 2183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
.clang-format Normal file
View File

@ -0,0 +1,29 @@
---
BasedOnStyle: LLVM
IndentWidth: 4
TabWidth: 4
---
Language: Cpp
AccessModifierOffset: -4
AlignAfterOpenBracket: AlwaysBreak
AlignOperands: false
AlignTrailingComments: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: true
AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: true
AlwaysBreakTemplateDeclarations: true
BinPackArguments: false
BinPackParameters: false
BreakConstructorInitializersBeforeComma: true
ColumnLimit: 160
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 0
MaxEmptyLinesToKeep: 2
NamespaceIndentation: All
PointerAlignment: Left
SpaceAfterCStyleCast: true
Standard: Cpp11
UseTab: Always
...

108
src/announce.c
View File

@ -2,12 +2,12 @@
#include "announce.h" #include "announce.h"
#include "network.h" #include "network.h"
#include <time.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <time.h>
#include <unistd.h>
#include <avahi-client/client.h> #include <avahi-client/client.h>
#include <avahi-client/lookup.h> #include <avahi-client/lookup.h>
@ -20,10 +20,10 @@
#define SERVICE_TYPE "_sdlbomber._udp" #define SERVICE_TYPE "_sdlbomber._udp"
static AvahiClient *client = NULL; static AvahiClient* client = NULL;
static AvahiThreadedPoll *threaded_poll = NULL; static AvahiThreadedPoll* threaded_poll = NULL;
static AvahiEntryGroup *group = NULL; static AvahiEntryGroup* group = NULL;
static AvahiServiceBrowser *browser = NULL; static AvahiServiceBrowser* browser = NULL;
static char* name = NULL; static char* name = NULL;
@ -37,22 +37,21 @@ static char buffer_glchanged[10];
gamelistentry gamelistentries[10]; gamelistentry gamelistentries[10];
int gamelistsize = 0; int gamelistsize = 0;
static void myerror(AvahiClient *c, const char *s) { static void myerror(AvahiClient* c, const char* s) {
fprintf(stderr, "Error in: %s\n (%s)", s, avahi_strerror(avahi_client_errno(c))); fprintf(stderr, "Error in: %s\n (%s)", s, avahi_strerror(avahi_client_errno(c)));
} }
static void create_services(AvahiClient *c); static void create_services(AvahiClient* c);
static void entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, AVAHI_GCC_UNUSED void *userdata) { static void entry_group_callback(AvahiEntryGroup* g, AvahiEntryGroupState state, AVAHI_GCC_UNUSED void* userdata) {
group = g; group = g;
switch (state) { switch (state) {
case AVAHI_ENTRY_GROUP_ESTABLISHED : case AVAHI_ENTRY_GROUP_ESTABLISHED:
break; break;
case AVAHI_ENTRY_GROUP_COLLISION : case AVAHI_ENTRY_GROUP_COLLISION: {
{ char* n = avahi_alternative_service_name(name);
char *n = avahi_alternative_service_name(name);
avahi_free(name); avahi_free(name);
name = n; name = n;
} }
@ -62,7 +61,7 @@ static void entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state,
create_services(avahi_entry_group_get_client(g)); create_services(avahi_entry_group_get_client(g));
break; break;
case AVAHI_ENTRY_GROUP_FAILURE : case AVAHI_ENTRY_GROUP_FAILURE:
fprintf(stderr, "Entry group failure: %s\n", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g)))); fprintf(stderr, "Entry group failure: %s\n", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g))));
avahi_threaded_poll_quit(threaded_poll); avahi_threaded_poll_quit(threaded_poll);
@ -74,7 +73,7 @@ static void entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state,
} }
} }
static void create_services(AvahiClient *c) { static void create_services(AvahiClient* c) {
int ret; int ret;
if (!group) { if (!group) {
@ -90,10 +89,9 @@ again:
snprintf(buf_version, sizeof(buf_version), "version=%X", (unsigned int) version); snprintf(buf_version, sizeof(buf_version), "version=%X", (unsigned int) version);
if ((ret = avahi_entry_group_add_service(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, 0, name, SERVICE_TYPE, NULL, NULL, port, buf_version, NULL)) < 0) { if ((ret = avahi_entry_group_add_service(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, 0, name, SERVICE_TYPE, NULL, NULL, port, buf_version, NULL)) < 0) {
if (ret == AVAHI_ERR_COLLISION) if (ret == AVAHI_ERR_COLLISION) goto collision;
goto collision;
fprintf(stderr, "Failed to add "SERVICE_TYPE": %s\n", avahi_strerror(ret)); fprintf(stderr, "Failed to add " SERVICE_TYPE ": %s\n", avahi_strerror(ret));
goto fail; goto fail;
} }
@ -105,12 +103,11 @@ again:
return; return;
collision: collision : {
{ char* n = avahi_alternative_service_name(name);
char *n = avahi_alternative_service_name(name);
avahi_free(name); avahi_free(name);
name = n; name = n;
} }
avahi_entry_group_reset(group); avahi_entry_group_reset(group);
goto again; goto again;
@ -118,8 +115,8 @@ fail:
avahi_threaded_poll_quit(threaded_poll); avahi_threaded_poll_quit(threaded_poll);
} }
static void client_callback(AvahiClient *c, AvahiClientState state, void * userdata) { static void client_callback(AvahiClient* c, AvahiClientState state, void* userdata) {
(void)userdata; (void) userdata;
client = c; client = c;
switch (state) { switch (state) {
@ -132,16 +129,14 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void * userd
break; break;
case AVAHI_CLIENT_S_COLLISION: case AVAHI_CLIENT_S_COLLISION:
case AVAHI_CLIENT_S_REGISTERING: case AVAHI_CLIENT_S_REGISTERING:
if (group) { if (group) { avahi_entry_group_reset(group); }
avahi_entry_group_reset(group);
}
break; break;
case AVAHI_CLIENT_CONNECTING: case AVAHI_CLIENT_CONNECTING:
break; break;
} }
} }
int registergame(const char *playername, uint16_t p, const unsigned char v[4]) { int registergame(const char* playername, uint16_t p, const unsigned char v[4]) {
if (name) avahi_free(name); if (name) avahi_free(name);
name = avahi_strdup(playername); name = avahi_strdup(playername);
@ -165,7 +160,7 @@ void unregistergame(void) {
avahi_threaded_poll_unlock(threaded_poll); avahi_threaded_poll_unlock(threaded_poll);
} }
static void remove_game_with_name(const char *name) { static void remove_game_with_name(const char* name) {
int i; int i;
for (i = 0; i < buffer_glsize; i++) { for (i = 0; i < buffer_glsize; i++) {
@ -180,15 +175,26 @@ static void remove_game_with_name(const char *name) {
} }
} }
static void resolve_callback(AvahiServiceResolver *r, AvahiIfIndex interface, AvahiProtocol protocol, AvahiResolverEvent event, static void resolve_callback(
const char *name, const char *type, const char *domain, const char *host_name, const AvahiAddress *address, AvahiServiceResolver* r,
uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags flags, void* userdata) { AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiResolverEvent event,
const char* name,
const char* type,
const char* domain,
const char* host_name,
const AvahiAddress* address,
uint16_t port,
AvahiStringList* txt,
AvahiLookupResultFlags flags,
void* userdata) {
int i; int i;
uint32_t want_version; uint32_t want_version;
(void)interface; (void) interface;
(void)host_name; (void) host_name;
(void)flags; (void) flags;
(void)userdata; (void) userdata;
assert(r); assert(r);
if (protocol != AVAHI_PROTO_INET) goto done; /* ignore non IPv4 for now */ if (protocol != AVAHI_PROTO_INET) goto done; /* ignore non IPv4 for now */
@ -201,15 +207,21 @@ static void resolve_callback(AvahiServiceResolver *r, AvahiIfIndex interface, Av
switch (event) { switch (event) {
case AVAHI_RESOLVER_FAILURE: case AVAHI_RESOLVER_FAILURE:
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r)))); fprintf(
stderr,
"(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n",
name,
type,
domain,
avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
break; break;
case AVAHI_RESOLVER_FOUND: { case AVAHI_RESOLVER_FOUND: {
gamelistentry *ge; gamelistentry* ge;
unsigned int version; unsigned int version;
int have_version = 0; int have_version = 0;
AvahiStringList *psl; AvahiStringList* psl;
for (psl = txt ; psl ; psl = psl->next) { for (psl = txt; psl; psl = psl->next) {
if (0 == strncmp("version=", (const char*) psl->text, 8)) { if (0 == strncmp("version=", (const char*) psl->text, 8)) {
sscanf((const char*) psl->text, "version=%X", &version); sscanf((const char*) psl->text, "version=%X", &version);
if (version != want_version) goto done; /* version mismatch */ if (version != want_version) goto done; /* version mismatch */
@ -233,9 +245,17 @@ done:
avahi_service_resolver_free(r); avahi_service_resolver_free(r);
} }
static void browse_callback(AvahiServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiBrowserEvent event, static void browse_callback(
const char *name, const char *type, const char *domain, AvahiLookupResultFlags flags, void* userdata) { AvahiServiceBrowser* b,
(void)flags; AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiBrowserEvent event,
const char* name,
const char* type,
const char* domain,
AvahiLookupResultFlags flags,
void* userdata) {
(void) flags;
assert(b); assert(b);

2
src/announce.h
View File

@ -9,7 +9,7 @@ struct gamelistentry {
char name[16]; char name[16];
}; };
int registergame(const char *playername, uint16_t port, const unsigned char version[4]); int registergame(const char* playername, uint16_t port, const unsigned char version[4]);
void unregistergame(void); void unregistergame(void);
int searchgames(void); int searchgames(void);

34
src/bomber.c
View File

@ -1,31 +1,31 @@
#include <fcntl.h>
#include <netdb.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <sys/types.h>
#include <netdb.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/time.h> #include <sys/time.h>
#include <signal.h> #include <sys/types.h>
#include <fcntl.h> #include <unistd.h>
#include <stdarg.h>
#include "bomber.h"
#include "gfx.h"
#include "announce.h" #include "announce.h"
#include "sound.h" #include "bomber.h"
#include "menu.h"
#include "utils.h"
#include "network.h"
#include "game.h"
#include "draw.h" #include "draw.h"
#include "game.h"
#include "gfx.h"
#include "menu.h"
#include "network.h"
#include "sound.h"
#include "utils.h"
int main(void) { int main(void) {
char *p; char* p;
strcpy(playername,"ANONYMOUS"); strcpy(playername, "ANONYMOUS");
p=getenv("USER"); p = getenv("USER");
if(p) strncpy(playername,p,sizeof(playername)-1); if (p) strncpy(playername, p, sizeof(playername) - 1);
create_seed_unique(); create_seed_unique();

65
src/bomber.h
View File

@ -1,7 +1,8 @@
#ifndef BOMBER_H #ifndef BOMBER_H
#define BOMBER_H #define BOMBER_H
#include "SDL.h" #include "list.h"
#include <SDL.h>
typedef unsigned char uchar; typedef unsigned char uchar;
extern int xcolors[256]; extern int xcolors[256];
@ -38,30 +39,25 @@ extern int xcolors[256];
typedef struct gfxset { typedef struct gfxset {
uchar gs_colormap[768]; uchar gs_colormap[768];
uchar gs_inout[256]; uchar gs_inout[256];
uchar *gs_pic; uchar* gs_pic;
int gs_xsize; int gs_xsize;
int gs_ysize; int gs_ysize;
} gfxset; } gfxset;
typedef struct figure { typedef struct figure {
int xsize,ysize; int xsize, ysize;
int xdelta,ydelta; int xdelta, ydelta;
uchar *graphics; uchar* graphics;
} figure; } figure;
typedef struct solid { typedef struct solid {
int xsize,ysize; int xsize, ysize;
uchar *graphics; uchar* graphics;
} solid; } solid;
typedef struct listhead listhead;
struct listhead {
listhead *prev, *next;
};
typedef struct player { typedef struct player {
listhead list, list_all_players; listhead list, list_all_players;
int xpos,ypos; int xpos, ypos;
int flags; int flags;
int abilities; int abilities;
int speed; int speed;
@ -69,15 +65,15 @@ typedef struct player {
int bombsused; int bombsused;
int bombsavailable; int bombsavailable;
int flamelength; int flamelength;
int *at; int* at;
int figcount; int figcount;
int doing; int doing;
int action; int action;
int color; int color;
int controller; int controller;
int fixx,fixy; int fixx, fixy;
int kills, deaths; int kills, deaths;
figure *figure; figure* figure;
} player; } player;
#define FLG_CONTROL 1 #define FLG_CONTROL 1
@ -86,24 +82,24 @@ typedef struct player {
typedef struct sprite { typedef struct sprite {
int flags; int flags;
int xpos,ypos; int xpos, ypos;
figure *fig; figure* fig;
} sprite; } sprite;
typedef struct damage { typedef struct damage {
int xpos,ypos; int xpos, ypos;
int xsize,ysize; int xsize, ysize;
} damage; } damage;
typedef struct bomb { typedef struct bomb {
listhead list; listhead list;
int type; int type;
int xpos,ypos; int xpos, ypos;
int px,py; int px, py;
int power; int power;
int timer; int timer;
int figcount; int figcount;
player *owner; player* owner;
} bomb; } bomb;
@ -117,11 +113,11 @@ typedef struct bomb {
typedef struct flame { typedef struct flame {
listhead list; listhead list;
int xpos,ypos; int xpos, ypos;
int px,py; int px, py;
int timer; int timer;
int lurd; int lurd;
player *owner; player* owner;
} flame; } flame;
#define FL_UP 2 #define FL_UP 2
@ -131,27 +127,27 @@ typedef struct flame {
typedef struct brickdecay { typedef struct brickdecay {
listhead list; listhead list;
int xpos,ypos; int xpos, ypos;
int px,py; int px, py;
int timer; int timer;
} brickdecay; } brickdecay;
typedef struct bonustile { typedef struct bonustile {
listhead list; listhead list;
int xpos,ypos; int xpos, ypos;
int px,py; int px, py;
int type; int type;
} bonustile; } bonustile;
typedef struct generic { typedef struct generic {
listhead list; listhead list;
int xpos,ypos; int xpos, ypos;
int px,py; int px, py;
int timer; int timer;
void (*process)(); void (*process)();
void (*draw)(); void (*draw)();
void *ptr1,*ptr2; void *ptr1, *ptr2;
int data1,data2; int data1, data2;
} generic; } generic;
enum tile_types { enum tile_types {
@ -200,7 +196,6 @@ enum tile_types {
#define CODE_ALLDEAD 2 #define CODE_ALLDEAD 2
#define MAXTHINGS 500 #define MAXTHINGS 500
#define MAXSETS 8 #define MAXSETS 8
#define MAXSPRITES 256 #define MAXSPRITES 256

442
src/draw.c
View File

@ -1,15 +1,15 @@
#include <fcntl.h>
#include <netdb.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <sys/types.h>
#include <netdb.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/time.h> #include <sys/time.h>
#include <signal.h> #include <sys/types.h>
#include <fcntl.h> #include <unistd.h>
#include <stdarg.h>
#include "bomber.h" #include "bomber.h"
#include "draw.h" #include "draw.h"
@ -48,183 +48,198 @@ figure flamefigs[MAXSETS][NUMFLAMEFRAMES];
figure tiles[15]; figure tiles[15];
figure death[NUMDEATHFRAMES]; figure death[NUMDEATHFRAMES];
int fontxsize,fontysize; int fontxsize, fontysize;
int bigfontxsize,bigfontysize,bigfontyspace; int bigfontxsize, bigfontysize, bigfontyspace;
static int textx,texty; static int textx, texty;
static const unsigned char *remapstring = (const unsigned char*) "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ.:!?\177/\\*-,>< ="; static const unsigned char* remapstring = (const unsigned char*) "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ.:!?\177/\\*-,>< =";
static char asciiremap[256]; static char asciiremap[256];
/* On screen array variables */ /* On screen array variables */
int arraynumx=15; int arraynumx = 15;
int arraynumy=11; int arraynumy = 11;
int arraystartx=20; int arraystartx = 20;
int arraystarty=70; int arraystarty = 70;
int arrayspacex=40; int arrayspacex = 40;
int arrayspacey=36; int arrayspacey = 36;
static sprite sprites[MAXSPRITES]; static sprite sprites[MAXSPRITES];
static int spritesused=0; static int spritesused = 0;
#define IBUFFLEN 1024 #define IBUFFLEN 1024
int ileft=0,ihand=0,byteswide; int ileft = 0, ihand = 0, byteswide;
unsigned char ibuff[IBUFFLEN],*itake; unsigned char ibuff[IBUFFLEN], *itake;
static void freegfxset(gfxset *gs) { static void freegfxset(gfxset* gs) {
if(gs->gs_pic) free(gs->gs_pic); if (gs->gs_pic) free(gs->gs_pic);
gs->gs_pic=0; gs->gs_pic = 0;
} }
static int myci() { static int myci() {
if (!ileft) { if (!ileft) {
ileft=read(ihand,ibuff,IBUFFLEN); ileft = read(ihand, ibuff, IBUFFLEN);
if(!ileft) return -1; if (!ileft) return -1;
itake=ibuff; itake = ibuff;
} }
ileft--; ileft--;
return *itake++; return *itake++;
} }
static int dopcxreal(char *name,gfxset *gs) { static int dopcxreal(char* name, gfxset* gs) {
int xs,ys; int xs, ys;
int i,j,k; int i, j, k;
int totalsize; int totalsize;
int width,height; int width, height;
unsigned char *bm,*lp; unsigned char *bm, *lp;
char tname[256]; char tname[256];
memset(gs,0,sizeof(gfxset)); memset(gs, 0, sizeof(gfxset));
ileft=0; ileft = 0;
snprintf(tname,sizeof(tname),DATADIR "/%s",name); snprintf(tname, sizeof(tname), DATADIR "/%s", name);
ihand=open(tname,O_RDONLY); ihand = open(tname, O_RDONLY);
if(ihand<0) { if (ihand < 0) {
char tname2[260]; char tname2[260];
snprintf(tname2,sizeof(tname2),"%s.pcx",tname); snprintf(tname2, sizeof(tname2), "%s.pcx", tname);
ihand=open(tname2,O_RDONLY); ihand = open(tname2, O_RDONLY);
if(ihand<0) if (ihand < 0) return 1;
return 1;
} }
if(myci()!=10) {close(ihand);return 2;} // 10=zsoft .pcx if (myci() != 10) {
if(myci()!=5) {close(ihand);return 3;} // version 3.0 close(ihand);
if(myci()!=1) {close(ihand);return 4;} //encoding method return 2;
if(myci()!=8) {close(ihand);return 5;} //bpp } // 10=zsoft .pcx
xs=myci(); if (myci() != 5) {
xs|=myci()<<8; close(ihand);
ys=myci(); return 3;
ys|=myci()<<8; } // version 3.0
width=myci(); if (myci() != 1) {
width|=myci()<<8; close(ihand);
height=myci(); return 4;
height|=myci()<<8; } // encoding method
width=width+1-xs; if (myci() != 8) {
height=height+1-ys; close(ihand);
for(i=0;i<48+4;++i) myci(); return 5;
} // bpp
xs = myci();
xs |= myci() << 8;
ys = myci();
ys |= myci() << 8;
width = myci();
width |= myci() << 8;
height = myci();
height |= myci() << 8;
width = width + 1 - xs;
height = height + 1 - ys;
for (i = 0; i < 48 + 4; ++i) myci();
myci(); myci();
if(myci()!=1) {close(ihand);return 6;} // # of planes if (myci() != 1) {
byteswide=myci(); close(ihand);
byteswide|=myci()<<8; return 6;
i=myci(); } // # of planes
i|=myci()<<8; byteswide = myci();
// if(i!=1) {close(ihand);return 7;} // 1=color/bw,2=grey byteswide |= myci() << 8;
for(i=0;i<58;++i) myci(); i = myci();
totalsize=height*byteswide; i |= myci() << 8;
bm=malloc(totalsize+1); // if(i!=1) {close(ihand);return 7;} // 1=color/bw,2=grey
if(!bm) {close(ihand);return 8;} // no memory for (i = 0; i < 58; ++i) myci();
gs->gs_pic=bm; totalsize = height * byteswide;
gs->gs_xsize=width; bm = malloc(totalsize + 1);
gs->gs_ysize=height; if (!bm) {
while(height--) { close(ihand);
lp=bm; return 8;
i=byteswide; } // no memory
while(i>0) { gs->gs_pic = bm;
j=myci(); gs->gs_xsize = width;
if(j<0xc0) { gs->gs_ysize = height;
*lp++=j; while (height--) {
lp = bm;
i = byteswide;
while (i > 0) {
j = myci();
if (j < 0xc0) {
*lp++ = j;
--i; --i;
} else { } else {
j&=0x3f; j &= 0x3f;
k=myci(); k = myci();
while(j-- && i) { while (j-- && i) {
*lp++=k; *lp++ = k;
--i; --i;
} }
} }
} }
bm+=width; bm += width;
} }
lseek(ihand,-0x300,SEEK_END); lseek(ihand, -0x300, SEEK_END);
read(ihand,gs->gs_colormap,0x300); read(ihand, gs->gs_colormap, 0x300);
close(ihand); close(ihand);
return 0; return 0;
} }
static int dopcx(char *name,gfxset *gs) { static int dopcx(char* name, gfxset* gs) {
int err; int err;
err=dopcxreal(name,gs); err = dopcxreal(name, gs);
if(err) if (err) printf("Error loading \"%s\":code %d\n", name, err);
printf("Error loading \"%s\":code %d\n",name,err);
return err; return err;
} }
static void getgroup(char *name,gfxset *colorgs,figure *fig,int count) { static void getgroup(char* name, gfxset* colorgs, figure* fig, int count) {
int err; int err;
int i; int i;
gfxset gs; gfxset gs;
err=dopcx(name,&gs); err = dopcx(name, &gs);
if(err) exit(1000+err); if (err) exit(1000 + err);
createinout(&gs); createinout(&gs);
for(i=0;i<MAXSETS;++i,fig+=count,++colorgs) { for (i = 0; i < MAXSETS; ++i, fig += count, ++colorgs) {
if(!colorgs->gs_pic) continue; if (!colorgs->gs_pic) continue;
memmove(gs.gs_colormap,colorgs->gs_colormap, memmove(gs.gs_colormap, colorgs->gs_colormap, sizeof(gs.gs_colormap));
sizeof(gs.gs_colormap));
createinout(&gs); createinout(&gs);
gfxfetch(&gs,fig,count); gfxfetch(&gs, fig, count);
} }
freegfxset(&gs); freegfxset(&gs);
} }
static void getsingle(char *name,figure *fig,int count) { static void getsingle(char* name, figure* fig, int count) {
gfxset gs; gfxset gs;
int err; int err;
err=dopcx(name,&gs); err = dopcx(name, &gs);
if(err) exit(1000+err); if (err) exit(1000 + err);
createinout(&gs); createinout(&gs);
gfxfetch(&gs,fig,count); gfxfetch(&gs, fig, count);
freegfxset(&gs); freegfxset(&gs);
} }
static void texthome(void) { static void texthome(void) {
textx=texty=10; textx = texty = 10;
} }
void drawstring(int xpos, int ypos, const char *str) { void drawstring(int xpos, int ypos, const char* str) {
char ch; char ch;
while((ch=*str++)) { while ((ch = *str++)) {
drawfigure(xpos,ypos,font+asciiremap[toupper(ch)]); drawfigure(xpos, ypos, font + asciiremap[toupper(ch)]);
xpos+=fontxsize; xpos += fontxsize;
} }
} }
void drawbigstring(int xpos, int ypos, const char *str) { void drawbigstring(int xpos, int ypos, const char* str) {
char ch; char ch;
while('\0' != (ch=*str++)) { while ('\0' != (ch = *str++)) {
drawfigure(xpos,ypos,bigfont+asciiremap[toupper(ch)]); drawfigure(xpos, ypos, bigfont + asciiremap[toupper(ch)]);
xpos+=bigfontxsize; xpos += bigfontxsize;
} }
} }
void centerbig(int y, const char *str) { void centerbig(int y, const char* str) {
int w; int w;
w=strlen(str)*bigfontxsize; w = strlen(str) * bigfontxsize;
drawbigstring((IXSIZE-w)>>1,y,str); drawbigstring((IXSIZE - w) >> 1, y, str);
} }
// static void scrprintf(char *str,...) { // static void scrprintf(char *str,...) {
@ -253,201 +268,196 @@ void centerbig(int y, const char *str) {
// copyup(); // copyup();
// } // }
static void bigscrprintf(char *str,...) { static void bigscrprintf(char* str, ...) {
char output[256],*p,*p2; char output[256], *p, *p2;
va_list ap; va_list ap;
va_start(ap, str); va_start(ap, str);
vsnprintf(output,sizeof(output),str,ap); vsnprintf(output, sizeof(output), str, ap);
p=output; p = output;
for(;;) { for (;;) {
p2=p; p2 = p;
while(*p2 && *p2!='\n') ++p2; while (*p2 && *p2 != '\n') ++p2;
if(*p2) { if (*p2) {
*p2=0; *p2 = 0;
drawbigstring(textx,texty,p); drawbigstring(textx, texty, p);
texty+=bigfontysize; texty += bigfontysize;
textx=10; textx = 10;
p=p2+1; p = p2 + 1;
} else { } else {
drawbigstring(textx,texty,p); drawbigstring(textx, texty, p);
textx+=bigfontxsize*(p2-p); textx += bigfontxsize * (p2 - p);
break; break;
} }
} }
copyup(); copyup();
} }
void addsprite(int x,int y,figure *fig) { void addsprite(int x, int y, figure* fig) {
sprite *sp; sprite* sp;
if(spritesused==MAXSPRITES) return; if (spritesused == MAXSPRITES) return;
sp=sprites+spritesused++; sp = sprites + spritesused++;
sp->flags=0; sp->flags = 0;
sp->xpos=x; sp->xpos = x;
sp->ypos=y; sp->ypos = y;
sp->fig=fig; sp->fig = fig;
} }
void plotsprites(void) { void plotsprites(void) {
int i; int i;
sprite *sp; sprite* sp;
sp=sprites; sp = sprites;
for(i=0;i<spritesused;++i) { for (i = 0; i < spritesused; ++i) {
drawfigure(sp->xpos,sp->ypos,sp->fig); drawfigure(sp->xpos, sp->ypos, sp->fig);
++sp; ++sp;
} }
} }
void erasesprites(void) { void erasesprites(void) {
int i; int i;
sprite *sp; sprite* sp;
figure *fig; figure* fig;
sp=sprites; sp = sprites;
for(i=0;i<spritesused;++i) { for (i = 0; i < spritesused; ++i) {
fig=sp->fig; fig = sp->fig;
solidcopy(&background, solidcopy(&background, sp->xpos + fig->xdelta, sp->ypos + fig->ydelta, fig->xsize, fig->ysize);
sp->xpos+fig->xdelta,sp->ypos+fig->ydelta,
fig->xsize,fig->ysize);
++sp; ++sp;
} }
} }
void clearsprites(void) { void clearsprites(void) {
int i; int i;
sprite *sp; sprite* sp;
figure *fig; figure* fig;
sp=sprites; sp = sprites;
for(i=0;i<spritesused;++i) { for (i = 0; i < spritesused; ++i) {
fig=sp->fig; fig = sp->fig;
clearrect(sp->xpos+fig->xdelta,sp->ypos+fig->ydelta, clearrect(sp->xpos + fig->xdelta, sp->ypos + fig->ydelta, fig->xsize, fig->ysize);
fig->xsize,fig->ysize);
++sp; ++sp;
} }
} }
void clearspritelist(void) { void clearspritelist(void) {
spritesused=0; spritesused = 0;
} }
int tovideox(int x) { int tovideox(int x) {
return (x>>FRACTION)+arraystartx; return (x >> FRACTION) + arraystartx;
} }
int tovideoy(int y) { int tovideoy(int y) {
return (y>>FRACTION)+arraystarty; return (y >> FRACTION) + arraystarty;
} }
int screentoarrayx(int x) { int screentoarrayx(int x) {
x+=arrayspacex << (FRACTION+2); x += arrayspacex << (FRACTION + 2);
return ((x>>FRACTION)+(arrayspacex>>1))/arrayspacex-4; return ((x >> FRACTION) + (arrayspacex >> 1)) / arrayspacex - 4;
} }
int screentoarrayy(int y) { int screentoarrayy(int y) {
y+=arrayspacey << (FRACTION+2); y += arrayspacey << (FRACTION + 2);
return ((y>>FRACTION)+(arrayspacey>>1))/arrayspacey-4; return ((y >> FRACTION) + (arrayspacey >> 1)) / arrayspacey - 4;
} }
int arraytoscreenx(int x) { int arraytoscreenx(int x) {
return arrayspacex*x<<FRACTION; return arrayspacex * x << FRACTION;
} }
int arraytoscreeny(int y) { int arraytoscreeny(int y) {
return arrayspacey*y<<FRACTION; return arrayspacey * y << FRACTION;
} }
static void loadfonts(void) { static void loadfonts(void) {
int i,j; int i, j;
const unsigned char *p; const unsigned char* p;
getsingle(fontname,font,NUMCHARACTERS); getsingle(fontname, font, NUMCHARACTERS);
getsingle(bigfontname,bigfont,NUMCHARACTERS); getsingle(bigfontname, bigfont, NUMCHARACTERS);
fontxsize=8; fontxsize = 8;
fontysize=12; fontysize = 12;
bigfontxsize=16; bigfontxsize = 16;
bigfontysize=24; bigfontysize = 24;
bigfontyspace=32; bigfontyspace = 32;
p=remapstring; p = remapstring;
j=0;while(*p && *p!=' ') ++p,++j; j = 0;
memset(asciiremap,j,sizeof(asciiremap)); while (*p && *p != ' ') ++p, ++j;
p=remapstring; memset(asciiremap, j, sizeof(asciiremap));
i=0; p = remapstring;
while(*p && i<NUMCHARACTERS) i = 0;
asciiremap[(int)*p++]=i++; while (*p && i < NUMCHARACTERS) asciiremap[(int) *p++] = i++;
} }
void loadgfx() { void loadgfx() {
gfxset *gs; gfxset* gs;
gfxset *colorgs; gfxset* colorgs;
int err; int err;
int i; int i;
char name[267]; char name[267];
strcpy(walkingname,"walk"); strcpy(walkingname, "walk");
strcpy(colorsetname,"pal"); strcpy(colorsetname, "pal");
strcpy(backgroundname,"field0"); strcpy(backgroundname, "field0");
strcpy(blocksname,"blocks3"); strcpy(blocksname, "blocks3");
strcpy(blocksxname,"blocks3x"); strcpy(blocksxname, "blocks3x");
strcpy(bombs1name,"bomb1"); strcpy(bombs1name, "bomb1");
strcpy(bombs2name,"bomb2"); strcpy(bombs2name, "bomb2");
strcpy(flamesname,"flames"); strcpy(flamesname, "flames");
strcpy(tilesname,"tiles"); strcpy(tilesname, "tiles");
strcpy(deathname,"death1"); strcpy(deathname, "death1");
strcpy(fontname,"font"); strcpy(fontname, "font");
strcpy(bigfontname,"bigfont"); strcpy(bigfontname, "bigfont");
gs=malloc((MAXSETS+1)*sizeof(gfxset)); gs = malloc((MAXSETS + 1) * sizeof(gfxset));
if(!gs) if (!gs) nomem("loadgfx");
nomem("loadgfx"); colorgs = gs + 1;
colorgs=gs+1;
for(i=0;i<MAXSETS;++i) { for (i = 0; i < MAXSETS; ++i) {
snprintf(name,sizeof(name),"%s%d",colorsetname,i); snprintf(name, sizeof(name), "%s%d", colorsetname, i);
err=dopcx(name,colorgs+i); err = dopcx(name, colorgs + i);
if(err) continue; if (err) continue;
} }
loadfonts(); loadfonts();
texthome(); texthome();
bigscrprintf("Loading graphics...\n"); bigscrprintf("Loading graphics...\n");
err=dopcx(backgroundname,gs); err = dopcx(backgroundname, gs);
if(err) exit(1000+err); if (err) exit(1000 + err);
createinout(gs); createinout(gs);
solidfetch(gs,&background); solidfetch(gs, &background);
solidfetch(gs,&backgroundoriginal); solidfetch(gs, &backgroundoriginal);
freegfxset(gs); freegfxset(gs);
bigscrprintf("Loading blocks\n"); bigscrprintf("Loading blocks\n");
getsingle(blocksname,blocks,3); getsingle(blocksname, blocks, 3);
bigscrprintf("Loading block explosions\n"); bigscrprintf("Loading block explosions\n");
getsingle(blocksxname,blocksx,9); getsingle(blocksxname, blocksx, 9);
bigscrprintf("Loading walking figures\n"); bigscrprintf("Loading walking figures\n");
getgroup(walkingname,colorgs,walking[0],NUMWALKFRAMES); getgroup(walkingname, colorgs, walking[0], NUMWALKFRAMES);
bigscrprintf("Loading normal bombs\n"); bigscrprintf("Loading normal bombs\n");
getgroup(bombs1name,colorgs,bombs1[0],NUMBOMBFRAMES); getgroup(bombs1name, colorgs, bombs1[0], NUMBOMBFRAMES);
bigscrprintf("Loading controlled bombs\n"); bigscrprintf("Loading controlled bombs\n");
getgroup(bombs2name,colorgs,bombs2[0],NUMBOMBFRAMES); getgroup(bombs2name, colorgs, bombs2[0], NUMBOMBFRAMES);
bigscrprintf("Loading flames\n"); bigscrprintf("Loading flames\n");
// getgroup(flamesname,colorgs,flamefigs[0],NUMFLAMEFRAMES); // getgroup(flamesname,colorgs,flamefigs[0],NUMFLAMEFRAMES);
getsingle(flamesname,flamefigs[0],NUMFLAMEFRAMES); getsingle(flamesname, flamefigs[0], NUMFLAMEFRAMES);
bigscrprintf("Loading bonus tiles\n"); bigscrprintf("Loading bonus tiles\n");
getsingle(tilesname,tiles,15); getsingle(tilesname, tiles, 15);
bigscrprintf("Loading death sequence\n"); bigscrprintf("Loading death sequence\n");
getsingle(deathname,death,NUMDEATHFRAMES); getsingle(deathname, death, NUMDEATHFRAMES);
for(i=0;i<MAXSETS;++i) for (i = 0; i < MAXSETS; ++i) freegfxset(colorgs + i);
freegfxset(colorgs+i);
free(gs); free(gs);
bigscrprintf("Done loading graphics\n"); bigscrprintf("Done loading graphics\n");
} }
void failure(char *str,...) { void failure(char* str, ...) {
char output[256]; char output[256];
va_list ap; va_list ap;
int len; int len;
@ -458,11 +468,11 @@ void failure(char *str,...) {
len = vsnprintf(output, sizeof(output), str, ap); len = vsnprintf(output, sizeof(output), str, ap);
if (len >= 256) len = 255; /* truncated string */ if (len >= 256) len = 255; /* truncated string */
clear(); clear();
drawbigstring((IXSIZE - len*bigfontxsize) / 2, (IYSIZE-bigfontysize) / 2, output); drawbigstring((IXSIZE - len * bigfontxsize) / 2, (IYSIZE - bigfontysize) / 2, output);
copyup(); copyup();
now = longtime(); now = longtime();
while (!exitflag && longtime()-now < 3) { while (!exitflag && longtime() - now < 3) {
scaninput(); scaninput();
if (anydown()) { if (anydown()) {
takedown(); takedown();

17
src/draw.h
View File

@ -3,12 +3,12 @@
void loadgfx(void); void loadgfx(void);
void drawstring(int xpos, int ypos, const char *str); void drawstring(int xpos, int ypos, const char* str);
void drawbigstring(int xpos, int ypos, const char *str); void drawbigstring(int xpos, int ypos, const char* str);
void centerbig(int y, const char *str); void centerbig(int y, const char* str);
void addsprite(int x,int y,figure *fig); void addsprite(int x, int y, figure* fig);
void plotsprites(void); void plotsprites(void);
void erasesprites(void); void erasesprites(void);
void clearsprites(void); void clearsprites(void);
@ -22,10 +22,10 @@ int screentoarrayy(int y);
int arraytoscreenx(int x); int arraytoscreenx(int x);
int arraytoscreeny(int y); int arraytoscreeny(int y);
void failure(char *str,...); void failure(char* str, ...);
extern int fontxsize,fontysize; extern int fontxsize, fontysize;
extern int bigfontxsize,bigfontysize,bigfontyspace; extern int bigfontxsize, bigfontysize, bigfontyspace;
/* On screen array variables */ /* On screen array variables */
extern int arraynumx, arraynumy, arraystartx, arraystarty, arrayspacex, arrayspacey; extern int arraynumx, arraynumy, arraystartx, arraystarty, arrayspacex, arrayspacey;
@ -37,6 +37,7 @@ extern int arraynumx, arraynumy, arraystartx, arraystarty, arrayspacex, arrayspa
#define NUMDEATHFRAMES 41 #define NUMDEATHFRAMES 41
extern figure blocks[3], blocksx[9], bombs1[MAXSETS][NUMBOMBFRAMES], bombs2[MAXSETS][NUMBOMBFRAMES], flamefigs[MAXSETS][NUMFLAMEFRAMES], tiles[15], death[NUMDEATHFRAMES]; extern figure blocks[3], blocksx[9], bombs1[MAXSETS][NUMBOMBFRAMES], bombs2[MAXSETS][NUMBOMBFRAMES], flamefigs[MAXSETS][NUMFLAMEFRAMES], tiles[15],
death[NUMDEATHFRAMES];
#endif #endif

799
src/game.c
View File

File diff suppressed because it is too large Load Diff

14
src/game.h
View File

@ -1,11 +1,13 @@
#ifndef GAME_H #ifndef GAME_H
#define GAME_H #define GAME_H
#include "bomber.h"
#define FRACTION 9 #define FRACTION 9
#define SPEEDDELTA (1<<(FRACTION-1)) #define SPEEDDELTA (1 << (FRACTION - 1))
#define SPEEDMAX (10<<FRACTION) #define SPEEDMAX (10 << FRACTION)
#define SPEEDSTART (6<<FRACTION) #define SPEEDSTART (6 << FRACTION)
#define SPEEDTURTLE (3<<FRACTION) #define SPEEDTURTLE (3 << FRACTION)
#define SPEEDTURTLE_TIMEOUT 250 #define SPEEDTURTLE_TIMEOUT 250
#define TEMPNODES 2 #define TEMPNODES 2
@ -18,10 +20,10 @@ struct GameOptions {
void run_single_player(void); void run_single_player(void);
void run_network_game(void); void run_network_game(void);
void set_game_options(GameOptions *options); void set_game_options(GameOptions* options);
extern char playername[16]; extern char playername[16];
extern solid background,backgroundoriginal; extern solid background, backgroundoriginal;
#endif #endif

1261
src/gfx.c
View File

File diff suppressed because it is too large Load Diff

56
src/gfx.h
View File

@ -8,15 +8,15 @@
extern int usedcolors; extern int usedcolors;
extern uchar mymap[]; extern uchar mymap[];
extern int screen; extern int screen;
extern int fontbase,fontysize; extern int fontbase, fontysize;
extern char *imageloc; extern char* imageloc;
extern long map2[]; extern long map2[];
extern uchar fmap[128]; extern uchar fmap[128];
extern int buttonstate,buttondown; extern int buttonstate, buttondown;
extern int mxpos,mypos; extern int mxpos, mypos;
extern int pressedcodes[KEYMAX],downcodes[KEYMAX],numpressed,numdown; extern int pressedcodes[KEYMAX], downcodes[KEYMAX], numpressed, numdown;
void opengfx(void); void opengfx(void);
@ -25,21 +25,21 @@ void gfxunlock(void);
void pollinput(void); void pollinput(void);
int takedown(void); int takedown(void);
void closegfx(void); void closegfx(void);
void greyrect(int x,int y,int xsize,int ysize); void greyrect(int x, int y, int xsize, int ysize);
void clearrect(int x,int y,int xsize,int ysize); void clearrect(int x, int y, int xsize, int ysize);
void solidfetch(gfxset *gs,solid *dest); void solidfetch(gfxset* gs, solid* dest);
extern void dumpgfx(void); extern void dumpgfx(void);
extern void createinout(struct gfxset *); extern void createinout(struct gfxset*);
extern void getcolors(void); extern void getcolors(void);
extern void gfxfetch(struct gfxset *,struct figure *,int); extern void gfxfetch(struct gfxset*, struct figure*, int);
extern void puttile(int destx,int desty,int source); extern void puttile(int destx, int desty, int source);
extern void store(int x,int y,int which); extern void store(int x, int y, int which);
extern void restore(int x,int y,int which); extern void restore(int x, int y, int which);
extern void copyup(void); extern void copyup(void);
extern void copyupxy(int x,int y); extern void copyupxy(int x, int y);
extern void copyupxysize(int x,int y,int xsize,int ysize); extern void copyupxysize(int x, int y, int xsize, int ysize);
extern void getfigures(void); extern void getfigures(void);
extern unsigned long getcolor(char *name); /* unsigned long */ extern unsigned long getcolor(char* name); /* unsigned long */
extern int checkpressed(int code); extern int checkpressed(int code);
extern int checkdown(int code); extern int checkdown(int code);
extern int checkbutton(int button); extern int checkbutton(int button);
@ -48,22 +48,22 @@ extern int anydown(void);
extern int firstdown(void); extern int firstdown(void);
extern void scaninput(void); extern void scaninput(void);
extern void fontinit(void); extern void fontinit(void);
extern void writechar(int x,int y,uchar ch); extern void writechar(int x, int y, uchar ch);
extern void clear(void); extern void clear(void);
extern void drawbox(int x,int y,int size,int color); extern void drawbox(int x, int y, int size, int color);
extern void drawbox2(int x,int y,int sizex,int sizey,int color); extern void drawbox2(int x, int y, int sizex, int sizey, int color);
extern void drawfillrect(int x,int y,int size,int color); extern void drawfillrect(int x, int y, int size, int color);
extern void bigpixel(int x,int y,int color); extern void bigpixel(int x, int y, int color);
extern void invert(int x,int y); extern void invert(int x, int y);
extern int getmousex(void); extern int getmousex(void);
extern int getmousey(void); extern int getmousey(void);
extern void drawsquare(int x,int y,uchar *source); extern void drawsquare(int x, int y, uchar* source);
extern void colormapon(void); extern void colormapon(void);
extern void colormapoff(void); extern void colormapoff(void);
extern void palette(uchar *pal); extern void palette(uchar* pal);
extern void drawfigure(int x,int y,figure *fig); extern void drawfigure(int x, int y, figure* fig);
extern void drawfigureany(int x,int y,figure *fig,solid *dest); extern void drawfigureany(int x, int y, figure* fig, solid* dest);
void solidcopy(solid *src,int destx,int desty,int sizex,int sizey); void solidcopy(solid* src, int destx, int desty, int sizex, int sizey);
void solidcopyany(solid *src,solid *dest,int destx,int desty,int sizex,int sizey); void solidcopyany(solid* src, solid* dest, int destx, int desty, int sizex, int sizey);
#endif // GFXX_H #endif // GFXX_H

32
src/list.c
View File

@ -1,11 +1,11 @@
#include "bomber.h"
#include "list.h" #include "list.h"
#include "bomber.h"
#include "utils.h" #include "utils.h"
typedef union genericlistitem genericlistitem; typedef union genericlistitem genericlistitem;
union genericlistitem { union genericlistitem {
genericlistitem *next; genericlistitem* next;
listhead list; listhead list;
bomb b; bomb b;
flame f; flame f;
@ -16,8 +16,8 @@ union genericlistitem {
}; };
/* doesn't use prev link */ /* doesn't use prev link */
static genericlistitem *things=0; static genericlistitem* things = 0;
static genericlistitem *free_things; static genericlistitem* free_things;
static int count_used = 0; static int count_used = 0;
@ -27,20 +27,18 @@ void alloc_things(void) {
if (!things) { if (!things) {
things = calloc(sizeof(genericlistitem), MAXTHINGS); things = calloc(sizeof(genericlistitem), MAXTHINGS);
} else { } else {
memset(things, 0, sizeof(genericlistitem)*MAXTHINGS); memset(things, 0, sizeof(genericlistitem) * MAXTHINGS);
} }
if (!things) nomem("Trying to allocate thing memory"); if (!things) nomem("Trying to allocate thing memory");
for (i=0; i < MAXTHINGS - 1; ++i) { for (i = 0; i < MAXTHINGS - 1; ++i) { things[i].next = &things[i + 1]; }
things[i].next = &things[i + 1];
}
things[i].next = 0; things[i].next = 0;
free_things = things; free_things = things;
count_used = 0; count_used = 0;
} }
void *_allocentry(size_t size) { void* _allocentry(size_t size) {
genericlistitem *entry = free_things; genericlistitem* entry = free_things;
if (size > sizeof(genericlistitem)) return 0; if (size > sizeof(genericlistitem)) return 0;
@ -52,33 +50,33 @@ void *_allocentry(size_t size) {
return entry; return entry;
} }
void freeentry(void *ptr) { void freeentry(void* ptr) {
genericlistitem *entry = ptr; genericlistitem* entry = ptr;
entry->next = free_things; entry->next = free_things;
free_things = entry; free_things = entry;
count_used--; count_used--;
} }
void list_add_tail(listhead *head, listhead *entry) { void list_add_tail(listhead* head, listhead* entry) {
entry->next = head; entry->next = head;
entry->prev = head->prev; entry->prev = head->prev;
head->prev->next = entry; head->prev->next = entry;
head->prev = entry; head->prev = entry;
} }
void list_del(listhead *entry) { void list_del(listhead* entry) {
entry->next->prev = entry->prev; entry->next->prev = entry->prev;
entry->prev->next = entry->next; entry->prev->next = entry->next;
entry->next = entry->prev = entry; entry->next = entry->prev = entry;
} }
void list_init_head(listhead *head) { void list_init_head(listhead* head) {
head->next = head; head->next = head;
head->prev = head; head->prev = head;
} }
void things_list_clear(listhead *head) { void things_list_clear(listhead* head) {
genericlistitem *entry; genericlistitem* entry;
while (head->next != head) { while (head->next != head) {
entry = container_of(head->next, __typeof__(*entry), list); entry = container_of(head->next, __typeof__(*entry), list);

29
src/list.h
View File

@ -1,10 +1,16 @@
#ifndef LIST_H #ifndef LIST_H
#define LIST_H #define LIST_H
#include <stddef.h>
/* from linux kernel (with some changes for "iso" c) */ /* from linux kernel (with some changes for "iso" c) */
#define container_of(ptr, type, member) \ typedef struct listhead listhead;
((type *)( (char *)(__typeof__( ((type *)0)->member ) *)(ptr) - offsetof(type,member))) struct listhead {
listhead *prev, *next;
};
#define container_of(ptr, type, member) ((type*) ((char*) (__typeof__(((type*) 0)->member)*) (ptr) -offsetof(type, member)))
/** /**
* list_entry - get the struct for this entry * list_entry - get the struct for this entry
@ -15,20 +21,20 @@
#define list_entry(ptr, type, member) container_of(ptr, type, member) #define list_entry(ptr, type, member) container_of(ptr, type, member)
void alloc_things(void); void alloc_things(void);
void *_allocentry(size_t size); void* _allocentry(size_t size);
#define allocentry(type) (type*) _allocentry(sizeof(type)) #define allocentry(type) (type*) _allocentry(sizeof(type))
void freeentry(void *ptr); void freeentry(void* ptr);
void list_add_tail(listhead *header, listhead *entry); void list_add_tail(listhead* header, listhead* entry);
#define addtail(head, entry) list_add_tail(head, &(entry->list)); #define addtail(head, entry) list_add_tail(head, &(entry->list));
/* remove entry from list */ /* remove entry from list */
void list_del(listhead *entry); void list_del(listhead* entry);
#define removeitem(entry) list_del(&(entry->list)); #define removeitem(entry) list_del(&(entry->list));
void list_init_head(listhead *head); void list_init_head(listhead* head);
void things_list_clear(listhead *head); /* listhead member must be the first member */ void things_list_clear(listhead* head); /* listhead member must be the first member */
/** /**
* list_for_each_entry - iterate over list of given type * list_for_each_entry - iterate over list of given type
@ -37,8 +43,7 @@ void things_list_clear(listhead *head); /* listhead member must be the first mem
* @member: the name of the list_struct within the struct. * @member: the name of the list_struct within the struct.
*/ */
#define list_for_each_entry(pos, head, member) \ #define list_for_each_entry(pos, head, member) \
for (pos = list_entry((head)->next, __typeof__(*pos), member); \ for (pos = list_entry((head)->next, __typeof__(*pos), member); /* prefetch(pos->member.next), */ \
/* prefetch(pos->member.next), */ \
&pos->member != (head); \ &pos->member != (head); \
pos = list_entry(pos->member.next, __typeof__(*pos), member)) pos = list_entry(pos->member.next, __typeof__(*pos), member))
@ -50,9 +55,7 @@ void things_list_clear(listhead *head); /* listhead member must be the first mem
* @member:>the name of the list_struct within the struct. * @member:>the name of the list_struct within the struct.
*/ */
#define list_for_each_entry_safe(pos, n, head, member) \ #define list_for_each_entry_safe(pos, n, head, member) \
for (pos = list_entry((head)->next, __typeof__(*pos), member), \ for (pos = list_entry((head)->next, __typeof__(*pos), member), n = list_entry(pos->member.next, __typeof__(*pos), member); &pos->member != (head); \
n = list_entry(pos->member.next, __typeof__(*pos), member); \
&pos->member != (head); \
pos = n, n = list_entry(n->member.next, __typeof__(*n), member)) pos = n, n = list_entry(n->member.next, __typeof__(*n), member))
#define list_empty(head) ((head) == (head)->next) #define list_empty(head) ((head) == (head)->next)

441
src/matcher.c
View File

@ -1,17 +1,17 @@
#include <arpa/inet.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/uio.h>
#include <sys/types.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/timeb.h>
#include <sys/time.h> #include <sys/time.h>
#include <sys/timeb.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <time.h> #include <time.h>
#include <signal.h>
#include <fcntl.h>
#define MAXMSG 256 #define MAXMSG 256
@ -20,7 +20,7 @@
#define TIMETOLIVE 600 // seconds #define TIMETOLIVE 600 // seconds
typedef unsigned char uchar; typedef unsigned char uchar;
char logging=0; char logging = 0;
unsigned char mesg[MAXMSG]; unsigned char mesg[MAXMSG];
int lastsize; int lastsize;
@ -35,8 +35,7 @@ char masterhostname[256];
#define MAXMATCHES 16 #define MAXMATCHES 16
struct registration struct registration {
{
uchar id; uchar id;
uchar unique[4]; uchar unique[4];
uchar password[4]; uchar password[4];
@ -44,16 +43,14 @@ struct registration
uchar name[16]; uchar name[16];
uchar status; uchar status;
}; };
struct query struct query {
{
uchar id; uchar id;
uchar password[4]; uchar password[4];
uchar version[4]; uchar version[4];
}; };
struct gamehost struct gamehost {
{ struct gamehost *next, *prev;
struct gamehost *next,*prev;
uchar machine[4]; uchar machine[4];
uchar port[2]; uchar port[2];
struct registration reg; struct registration reg;
@ -61,107 +58,93 @@ struct gamehost
}; };
struct gamehost *freehosts=0,*activehosts=0; struct gamehost *freehosts = 0, *activehosts = 0;
int udpsocket, myport;
int udpsocket,myport; struct sockaddr_in myname = {0}, mastername = {0};
struct sockaddr_in myname={0},mastername={0};
socklen_t senderlength; socklen_t senderlength;
struct sockaddr_in sender={0}; struct sockaddr_in sender = {0};
long longtime(void) long longtime(void) {
{ struct timeb tb;
struct timeb tb;
ftime(&tb); ftime(&tb);
return tb.time; return tb.time;
} }
char *timestr() char* timestr() {
{ static char timestring[80];
static char timestring[80];
time_t t; time_t t;
int l; int l;
time(&t); time(&t);
strcpy(timestring,ctime(&t)); strcpy(timestring, ctime(&t));
l=strlen(timestring); l = strlen(timestring);
if(l && timestring[l-1]=='\n') timestring[l-1]=0; if (l && timestring[l - 1] == '\n') timestring[l - 1] = 0;
return timestring; return timestring;
} }
int putmsg(struct sockaddr_in *toname,unsigned char *msg,int len) int putmsg(struct sockaddr_in* toname, unsigned char* msg, int len) {
{ int status;
int status;
status=sendto(udpsocket,msg,len,0, status = sendto(udpsocket, msg, len, 0, (struct sockaddr*) toname, sizeof(struct sockaddr_in));
(struct sockaddr *)toname,sizeof(struct sockaddr_in));
return status; return status;
} }
void ack() void ack() {
{ uchar copy[256];
uchar copy[256];
*copy=PKT_ACK; *copy = PKT_ACK;
memmove(copy+1,mesg,lastsize); memmove(copy + 1, mesg, lastsize);
putmsg(&sender,copy,lastsize+1); putmsg(&sender, copy, lastsize + 1);
} }
int getmsg(int seconds) int getmsg(int seconds) {
{ int size;
int size;
lastsize=-1; lastsize = -1;
memset(&sender,0,sizeof(sender)); memset(&sender, 0, sizeof(sender));
senderlength=sizeof(sender); senderlength = sizeof(sender);
if(seconds) if (seconds) {
{
struct timeval timeout; struct timeval timeout;
fd_set readfds; fd_set readfds;
int res; int res;
timeout.tv_sec=seconds; timeout.tv_sec = seconds;
timeout.tv_usec=0; timeout.tv_usec = 0;
FD_ZERO(&readfds); FD_ZERO(&readfds);
FD_SET(udpsocket,&readfds); FD_SET(udpsocket, &readfds);
res=select(udpsocket+1,&readfds,0,0,&timeout); res = select(udpsocket + 1, &readfds, 0, 0, &timeout);
if(res<=0) return -1; if (res <= 0) return -1;
} }
lastsize=size=recvfrom(udpsocket,mesg,MAXMSG,0, lastsize = size = recvfrom(udpsocket, mesg, MAXMSG, 0, (struct sockaddr*) &sender, &senderlength);
(struct sockaddr *)&sender,&senderlength);
return size; return size;
} }
long longind(unsigned char *p) long longind(unsigned char* p) {
{ return (p[0] << 24L) | (p[1] << 16L) | (p[2] << 8) | p[3];
return (p[0]<<24L) | (p[1]<<16L) | (p[2]<<8) | p[3];
} }
short shortind(unsigned char *p) short shortind(unsigned char* p) {
{ return (p[0] << 8L) | p[1];
return (p[0]<<8L) | p[1];
} }
void openport(int portwant) void openport(int portwant) {
{ int status;
int status;
myport=portwant; myport = portwant;
udpsocket=socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP); udpsocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(udpsocket==-1) if (udpsocket == -1) {
{
perror("socket()"); perror("socket()");
exit(1); exit(1);
} }
memset(&myname,0,sizeof(myname)); memset(&myname, 0, sizeof(myname));
myname.sin_family=AF_INET; myname.sin_family = AF_INET;
myname.sin_addr.s_addr=htonl(INADDR_ANY); myname.sin_addr.s_addr = htonl(INADDR_ANY);
myname.sin_port=htons(myport); myname.sin_port = htons(myport);
status=bind(udpsocket,(struct sockaddr *) &myname,sizeof(myname)); status = bind(udpsocket, (struct sockaddr*) &myname, sizeof(myname));
if(status==-1) if (status == -1) {
{
perror("bind()"); perror("bind()");
exit(1); exit(1);
} }
@ -169,224 +152,206 @@ int status;
#define PERBLOCK 512 #define PERBLOCK 512
struct gamehost *newhost() struct gamehost* newhost() {
{ struct gamehost *h, *block;
struct gamehost *h,*block; int i;
int i;
if(!freehosts) if (!freehosts) {
{ block = malloc(sizeof(struct gamehost) * PERBLOCK);
block=malloc(sizeof(struct gamehost)*PERBLOCK); if (!block) return 0;
if(!block) return 0; freehosts = block;
freehosts=block; i = PERBLOCK - 1;
i=PERBLOCK-1; while (i--) {
while(i--) block->next = block + 1;
{
block->next=block+1;
++block; ++block;
} }
block->next=0; block->next = 0;
} }
h=freehosts; h = freehosts;
freehosts=freehosts->next; freehosts = freehosts->next;
memset(h,0,sizeof(struct gamehost)); memset(h, 0, sizeof(struct gamehost));
return h; return h;
} }
void freehost(struct gamehost *h) void freehost(struct gamehost* h) {
{ h->next = freehosts;
h->next=freehosts; freehosts = h;
freehosts=h;
} }
struct gamehost *findmatch(struct registration *key) struct gamehost* findmatch(struct registration* key) {
{ struct gamehost* h;
struct gamehost *h; h = activehosts;
h=activehosts; while (h) {
while(h) if (!memcmp(&h->reg, key, sizeof(struct registration) - 1)) return h;
{ h = h->next;
if(!memcmp(&h->reg,key,sizeof(struct registration)-1))
return h;
h=h->next;
} }
return 0; return 0;
} }
void insert(struct gamehost* h) {
void insert(struct gamehost *h) if (activehosts) {
{ h->next = activehosts;
if(activehosts) h->prev = activehosts->prev;
{ activehosts->prev = h;
h->next=activehosts; activehosts = h;
h->prev=activehosts->prev; } else {
activehosts->prev=h; h->next = h->prev = 0;
activehosts=h; activehosts = h;
} else
{
h->next=h->prev=0;
activehosts=h;
} }
} }
void delete(struct gamehost *h) void delete (struct gamehost* h) {
{ if (h->prev)
if(h->prev) h->prev->next = h->next;
h->prev->next=h->next;
else else
activehosts=h->next; activehosts = h->next;
if(h->next) if (h->next) h->next->prev = h->prev;
h->next->prev=h->prev;
freehost(h); freehost(h);
} }
void doreg() void doreg() {
{ struct registration* new;
struct registration *new; struct gamehost* match;
struct gamehost *match; long now;
long now;
new=(struct registration *)mesg; new = (struct registration*) mesg;
match=findmatch(new); match = findmatch(new);
if(logging) if (logging) {
{ unsigned addr = ntohl(sender.sin_addr.s_addr);
unsigned addr=ntohl(sender.sin_addr.s_addr); unsigned short port = ntohs(sender.sin_port);
unsigned short port=ntohs(sender.sin_port); printf(
printf("reg :%s:%d.%d.%d.%d:%d %c%lx '%s'\n",timestr(), "reg :%s:%d.%d.%d.%d:%d %c%lx '%s'\n",
(addr>>24)&255,(addr>>16)&255,(addr>>8)&255,addr&255,port, timestr(),
new->status ? '+' : '-',(long)match,new->name); (addr >> 24) & 255,
(addr >> 16) & 255,
(addr >> 8) & 255,
addr & 255,
port,
new->status ? '+' : '-',
(long) match,
new->name);
fflush(stdout); fflush(stdout);
} }
if(!match && !new->status) {ack();return;} if (!match && !new->status) {
if(match && new->status) {ack();return;} ack();
if(!match && new->status) return;
{ }
match=newhost(); if (match && new->status) {
if(!match) return; // No memory, what can we do? ack();
memmove(match->machine,&sender.sin_addr.s_addr,4); return;
memmove(match->port,&sender.sin_port,2); }
match->reg=*new; if (!match && new->status) {
now=longtime(); match = newhost();
match->timeout=now+TIMETOLIVE; if (!match) return; // No memory, what can we do?
memmove(match->machine, &sender.sin_addr.s_addr, 4);
memmove(match->port, &sender.sin_port, 2);
match->reg = *new;
now = longtime();
match->timeout = now + TIMETOLIVE;
ack(); ack();
insert(match); insert(match);
return; return;
} else // match && !new->status } else // match && !new->status
{ {
delete(match); delete (match);
ack(); ack();
return; return;
} }
} }
void doquery() void doquery() {
{ uchar* password;
uchar *password; uchar* version;
uchar *version; struct gamehost* h;
struct gamehost *h; uchar response[2048], *rput, *countersave;
uchar response[2048],*rput,*countersave; int counter;
int counter;
if(logging) if (logging) {
{ unsigned addr = ntohl(sender.sin_addr.s_addr);
unsigned addr=ntohl(sender.sin_addr.s_addr); unsigned short port = ntohs(sender.sin_port);
unsigned short port=ntohs(sender.sin_port); printf("query:%s:%d.%d.%d.%d:%d\n", timestr(), (addr >> 24) & 255, (addr >> 16) & 255, (addr >> 8) & 255, addr & 255, port);
printf("query:%s:%d.%d.%d.%d:%d\n",timestr(),
(addr>>24)&255,(addr>>16)&255,(addr>>8)&255,addr&255,port);
fflush(stdout); fflush(stdout);
} }
password=mesg+1; password = mesg + 1;
version=mesg+5; version = mesg + 5;
h=activehosts; h = activehosts;
rput=response; rput = response;
*rput++=PKT_INFO; *rput++ = PKT_INFO;
memmove(rput,password,4); memmove(rput, password, 4);
rput+=4; rput += 4;
memmove(rput,version,4); memmove(rput, version, 4);
rput+=4; rput += 4;
countersave=rput; countersave = rput;
*rput++=0; *rput++ = 0;
*rput++=0; *rput++ = 0;
counter=0; counter = 0;
while(h) while (h) {
{ if (!memcmp(password, h->reg.password, 4) && !memcmp(version, h->reg.version, 4) && counter < MAXMATCHES) {
if(!memcmp(password,h->reg.password,4) &&
!memcmp(version,h->reg.version,4) && counter<MAXMATCHES)
{
++counter; ++counter;
memmove(rput,h->reg.unique,4); memmove(rput, h->reg.unique, 4);
rput+=4; rput += 4;
memmove(rput,h->machine,4); memmove(rput, h->machine, 4);
rput+=4; rput += 4;
memmove(rput,h->port,2); memmove(rput, h->port, 2);
rput+=2; rput += 2;
memmove(rput,h->reg.name,sizeof(h->reg.name)); memmove(rput, h->reg.name, sizeof(h->reg.name));
rput+=sizeof(h->reg.name); rput += sizeof(h->reg.name);
} }
h=h->next; h = h->next;
} }
*countersave++=counter>>8; *countersave++ = counter >> 8;
*countersave++=counter; *countersave++ = counter;
putmsg(&sender,response,rput-response); putmsg(&sender, response, rput - response);
} }
void purge(long cutoff) void purge(long cutoff) {
{ struct gamehost *h, *h2;
struct gamehost *h,*h2; h = activehosts;
h=activehosts; while (h) {
while(h) h2 = h;
{ h = h->next;
h2=h; if (cutoff - h2->timeout > 0) { delete (h2); }
h=h->next;
if(cutoff-h2->timeout>0)
{
delete(h2);
}
} }
} }
int main(int argc,char **argv) int main(int argc, char** argv) {
{ int i;
int i; int want;
int want; int size;
int size; long purgetime;
long purgetime; long now;
long now;
want=PORT; want = PORT;
if(argc>1) if (argc > 1) {
{ for (i = 1; i < argc; ++i)
for(i=1;i<argc;++i) if (!strncmp(argv[i], "-p", 2)) {
if(!strncmp(argv[i],"-p",2)) if (strlen(argv[i]) > 2)
{ want = atoi(argv[i] + 2);
if(strlen(argv[i])>2) want=atoi(argv[i]+2); else if (i + 1 < argc)
else if(i+1<argc) want=atoi(argv[i+1]); want = atoi(argv[i + 1]);
} }
} }
freehosts=0; freehosts = 0;
openport(want); openport(want);
purgetime=longtime()+TIMETOLIVE; purgetime = longtime() + TIMETOLIVE;
for(;;) for (;;) {
{ size = getmsg(10);
size=getmsg(10); if (size >= 1) switch (*mesg) {
if(size>=1)
switch(*mesg)
{
case PKT_REGISTER: case PKT_REGISTER:
if(size<sizeof(struct registration)) continue; if (size < sizeof(struct registration)) continue;
doreg(); doreg();
break; break;
case PKT_QUERY: case PKT_QUERY:
if(size<sizeof(struct query)) continue; if (size < sizeof(struct query)) continue;
doquery(); doquery();
break; break;
} }
now=longtime(); now = longtime();
if(now-purgetime>0) // avoid year 203x bug... if (now - purgetime > 0) // avoid year 203x bug...
{ {
purge(purgetime); purge(purgetime);
purgetime+=TIMETOLIVE; purgetime += TIMETOLIVE;
} }
} }
} }

247
src/menu.c
View File

@ -1,73 +1,66 @@
#include "bomber.h"
#include "menu.h" #include "menu.h"
#include "draw.h"
#include "gfx.h"
#include "utils.h"
#include "sound.h"
#include "network.h"
#include "announce.h" #include "announce.h"
#include "bomber.h"
#include "draw.h"
#include "game.h" #include "game.h"
#include "gfx.h"
#include "network.h"
#include "sound.h"
#include "utils.h"
GameOptions configopts = { 2, 1, 0, 2 }; GameOptions configopts = {2, 1, 0, 2};
/* Generic menu */ /* Generic menu */
typedef enum { typedef enum { MENU_ANY = -1, MENU_MAIN = 0, MENU_CONFIG = 2, MENU_JOIN = 3 } menuname;
MENU_ANY = -1,
MENU_MAIN = 0,
MENU_CONFIG = 2,
MENU_JOIN = 3
} menuname;
#define MENU_SELECT(x) ((menuname) (-x-1)) #define MENU_SELECT(x) ((menuname)(-x - 1))
static int menuhistory[32]={0}; static int menuhistory[32] = {0};
static char menustring[1024]; static char menustring[1024];
static char *menuput,*menuitems[40],*menutitle; static char *menuput, *menuitems[40], *menutitle;
static int menunum, menuexit; static int menunum, menuexit;
static int menudelta; static int menudelta;
static void drawmenu(int selected) { static void drawmenu(int selected) {
int i,j; int i, j;
int tx,ty; int tx, ty;
clear(); clear();
j=strlen(menutitle)*bigfontxsize; j = strlen(menutitle) * bigfontxsize;
drawbigstring((IXSIZE-j) >> 1,20,menutitle); drawbigstring((IXSIZE - j) >> 1, 20, menutitle);
ty=((IYSIZE-(bigfontysize*menunum))>>1)-(IYSIZE>>3); ty = ((IYSIZE - (bigfontysize * menunum)) >> 1) - (IYSIZE >> 3);
for(i=0;i<menunum;++i) for (i = 0; i < menunum; ++i) {
{ j = strlen(menuitems[i]) * bigfontxsize;
j=strlen(menuitems[i])*bigfontxsize; tx = (IXSIZE - j) >> 1;
tx=(IXSIZE-j) >> 1; if (i == selected) {
if(i==selected) greyrect(0, ty - 1, tx - 5, bigfontysize);
{ greyrect(tx + j + 3, ty - 1, IXSIZE - (tx + j + 3), bigfontysize);
greyrect(0,ty-1,tx-5,bigfontysize);
greyrect(tx+j+3,ty-1,IXSIZE-(tx+j+3),bigfontysize);
} }
drawbigstring(tx,ty,menuitems[i]); drawbigstring(tx, ty, menuitems[i]);
ty+=bigfontyspace; ty += bigfontyspace;
} }
} }
static int domenu(menuname whichmenu, int (*pause)(void)) { static int domenu(menuname whichmenu, int (*pause)(void)) {
char redraw; char redraw;
int selected; int selected;
int mcount=0; int mcount = 0;
if(whichmenu>=0) if (whichmenu >= 0)
selected=menuhistory[whichmenu]; selected = menuhistory[whichmenu];
else else
selected=-whichmenu-1; selected = -whichmenu - 1;
if (!pause) pause=mypause; if (!pause) pause = mypause;
redraw=1; redraw = 1;
clearspritelist(); clearspritelist();
while(!exitflag) { while (!exitflag) {
if(redraw) { if (redraw) {
drawmenu(selected); drawmenu(selected);
redraw=0; redraw = 0;
} }
if (!pause()) return -1; if (!pause()) return -1;
scaninput(); scaninput();
@ -75,37 +68,37 @@ static int domenu(menuname whichmenu, int (*pause)(void)) {
clearsprites(); clearsprites();
clearspritelist(); clearspritelist();
addsprite(IXSIZE/2-50-20,IYSIZE-80,walking[2]+(30+mcount%15)); addsprite(IXSIZE / 2 - 50 - 20, IYSIZE - 80, walking[2] + (30 + mcount % 15));
addsprite(IXSIZE/2+50-20,IYSIZE-80,walking[3]+(30+(mcount+7)%15)); addsprite(IXSIZE / 2 + 50 - 20, IYSIZE - 80, walking[3] + (30 + (mcount + 7) % 15));
plotsprites(); plotsprites();
copyup(); copyup();
if(anydown()) playsound(3); if (anydown()) playsound(3);
while(anydown()) { while (anydown()) {
switch(takedown()) { switch (takedown()) {
case MYLEFT: case MYLEFT:
menudelta=-1; menudelta = -1;
return selected; return selected;
case MYRIGHT: case MYRIGHT:
case ' ': case ' ':
case 13: case 13:
menudelta=1; menudelta = 1;
return selected; return selected;
case 'k': case 'k':
case MYUP: case MYUP:
if (selected) --selected; if (selected)
else selected=menunum-1; --selected;
if (whichmenu>=0) else
menuhistory[whichmenu]=selected; selected = menunum - 1;
redraw=1; if (whichmenu >= 0) menuhistory[whichmenu] = selected;
redraw = 1;
break; break;
case 'j': case 'j':
case MYDOWN: case MYDOWN:
++selected; ++selected;
if (selected==menunum) selected=0; if (selected == menunum) selected = 0;
if (whichmenu>=0) if (whichmenu >= 0) menuhistory[whichmenu] = selected;
menuhistory[whichmenu]=selected; redraw = 1;
redraw=1;
break; break;
case 0x1b: case 0x1b:
if (MENU_MAIN == whichmenu && menuexit != selected) { if (MENU_MAIN == whichmenu && menuexit != selected) {
@ -123,45 +116,45 @@ static int domenu(menuname whichmenu, int (*pause)(void)) {
} }
static void menustart() { static void menustart() {
menunum=-1; menunum = -1;
menuput=menustring; menuput = menustring;
*menuput=0; *menuput = 0;
menuexit = 0; menuexit = 0;
} }
static void additem_s(char *item, int len) { static void additem_s(char* item, int len) {
if (len < 0 || (menustring+sizeof(menustring)-menuput <= len)) return; if (len < 0 || (menustring + sizeof(menustring) - menuput <= len)) return;
if(menunum<0) if (menunum < 0)
menutitle=menuput; menutitle = menuput;
else else
menuitems[menunum]=menuput; menuitems[menunum] = menuput;
++menunum; ++menunum;
memcpy(menuput,item,len+1); memcpy(menuput, item, len + 1);
menuput += len+1; menuput += len + 1;
} }
static void additem(char *item,...) { static void additem(char* item, ...) {
char output[256]; char output[256];
va_list ap; va_list ap;
int len; int len;
va_start(ap, item); va_start(ap, item);
len = vsnprintf(output,sizeof(output),item,ap); len = vsnprintf(output, sizeof(output), item, ap);
if (len >= 256) len = 255; /* truncated string */ if (len >= 256) len = 255; /* truncated string */
additem_s(output, len); additem_s(output, len);
} }
static void addexit(char *item,...) { static void addexit(char* item, ...) {
char output[256]; char output[256];
va_list ap; va_list ap;
int len; int len;
va_start(ap, item); va_start(ap, item);
len = vsnprintf(output,sizeof(output),item,ap); len = vsnprintf(output, sizeof(output), item, ap);
if (len >= 256) len = 255; /* truncated string */ if (len >= 256) len = 255; /* truncated string */
menuexit = menunum; menuexit = menunum;
@ -173,9 +166,9 @@ static void addexit(char *item,...) {
/* game menues */ /* game menues */
static const char *densities[]={"PACKED","HIGH","MEDIUM","LOW"}; static const char* densities[] = {"PACKED", "HIGH", "MEDIUM", "LOW"};
static const char *generosities[]={"LOW","MEDIUM","HIGH","RIDICULOUS"}; static const char* generosities[] = {"LOW", "MEDIUM", "HIGH", "RIDICULOUS"};
static const char *dis_en_abled[]={"DISABLED","ENABLED"}; static const char* dis_en_abled[] = {"DISABLED", "ENABLED"};
static void config_menu(void) { static void config_menu(void) {
int sel; int sel;
@ -184,30 +177,30 @@ static void config_menu(void) {
menustart(); menustart();
additem("GAME OPTIONS"); additem("GAME OPTIONS");
additem("RETURN TO MAIN MENU"); additem("RETURN TO MAIN MENU");
additem("DENSITY: %s",densities[configopts.density]); additem("DENSITY: %s", densities[configopts.density]);
additem("GENEROSITY: %s",generosities[configopts.generosity]); additem("GENEROSITY: %s", generosities[configopts.generosity]);
additem("INITIAL FLAME LENGTH: %d",configopts.flames+1); additem("INITIAL FLAME LENGTH: %d", configopts.flames + 1);
additem("INITIAL NUMBER OF BOMBS: %d",configopts.bombs+1); additem("INITIAL NUMBER OF BOMBS: %d", configopts.bombs + 1);
additem("SOUND: %s", dis_en_abled[sound_enabled]); additem("SOUND: %s", dis_en_abled[sound_enabled]);
sel=domenu(MENU_CONFIG, NULL); sel = domenu(MENU_CONFIG, NULL);
switch (sel) { switch (sel) {
case 0: case 0:
return; return;
case 1: case 1:
configopts.density+=menudelta; configopts.density += menudelta;
configopts.density&=3; configopts.density &= 3;
break; break;
case 2: case 2:
configopts.generosity+=menudelta; configopts.generosity += menudelta;
configopts.generosity&=3; configopts.generosity &= 3;
break; break;
case 3: case 3:
configopts.flames+=menudelta; configopts.flames += menudelta;
configopts.flames&=7; configopts.flames &= 7;
break; break;
case 4: case 4:
configopts.bombs+=menudelta; configopts.bombs += menudelta;
configopts.bombs&=7; configopts.bombs &= 7;
break; break;
case 5: case 5:
sound_enabled = 1 - sound_enabled; sound_enabled = 1 - sound_enabled;
@ -218,20 +211,20 @@ static void config_menu(void) {
static void draw_host_game(void) { static void draw_host_game(void) {
int i; int i;
char *name; char* name;
char temp[64]; char temp[64];
#define M3X (IXSIZE/3) #define M3X (IXSIZE / 3)
#define M3Y (IYSIZE/4) #define M3Y (IYSIZE / 4)
clear(); clear();
centerbig(20,"HOST NETWORK GAME"); centerbig(20, "HOST NETWORK GAME");
drawbigstring(M3X,M3Y,"SLOT NAME"); drawbigstring(M3X, M3Y, "SLOT NAME");
for(i=0;i<MAXNETNODES;++i) { for (i = 0; i < MAXNETNODES; ++i) {
if(!netnodes[i].used) continue; if (!netnodes[i].used) continue;
name=netnodes[i].name; name = netnodes[i].name;
snprintf(temp,sizeof(temp)," %d %s",i+1,name); snprintf(temp, sizeof(temp), " %d %s", i + 1, name);
drawbigstring(M3X,M3Y+(i+2)*bigfontyspace,temp); drawbigstring(M3X, M3Y + (i + 2) * bigfontyspace, temp);
} }
copyup(); copyup();
@ -246,10 +239,10 @@ static void host_game(void) {
} }
draw_host_game(); draw_host_game();
for(;;) { for (;;) {
scaninput(); scaninput();
while(anydown()) { while (anydown()) {
switch(takedown()) { switch (takedown()) {
case 0x1b: case 0x1b:
unregistergame(); unregistergame();
cancel_network_game(); cancel_network_game();
@ -278,27 +271,25 @@ static void drawjoinscreen(void) {
char name[17]; char name[17];
char temp[64]; char temp[64];
#define JX (IXSIZE/3) #define JX (IXSIZE / 3)
#define JY (IYSIZE/4) #define JY (IYSIZE / 4)
clear(); clear();
centerbig(20,"JOIN NETWORK GAME"); centerbig(20, "JOIN NETWORK GAME");
drawbigstring(JX,JY,"SLOT NAME"); drawbigstring(JX, JY, "SLOT NAME");
for (i = 0; i < MAXNETNODES; ++i) { for (i = 0; i < MAXNETNODES; ++i) {
if(!netnodes[i].used) continue; if (!netnodes[i].used) continue;
memmove(name,netnodes[i].name,16); memmove(name, netnodes[i].name, 16);
name[16]=0; name[16] = 0;
snprintf(temp,sizeof(temp)," %d %s",i+1,name); snprintf(temp, sizeof(temp), " %d %s", i + 1, name);
drawbigstring(JX,JY+(i+1)*bigfontyspace,temp); drawbigstring(JX, JY + (i + 1) * bigfontyspace, temp);
} }
} }
static int tryjoin(int which) { static int tryjoin(int which) {
int res; int res;
if (0 == (res = send_join(&gamelistentries[which].netname, playername))) { if (0 == (res = send_join(&gamelistentries[which].netname, playername))) { return 0; }
return 0;
}
while (!exitflag) { while (!exitflag) {
switch (res) { switch (res) {
@ -309,18 +300,20 @@ static int tryjoin(int which) {
drawjoinscreen(); drawjoinscreen();
copyup(); copyup();
break; break;
case 3: return 1; case 3:
default: break; return 1;
default:
break;
} }
scaninput(); scaninput();
while(anydown()) { while (anydown()) {
switch(takedown()) { switch (takedown()) {
case 0x1b: case 0x1b:
send_quit(); send_quit();
return 0; return 0;
} }
} }
res=scaninvite(200); res = scaninvite(200);
} }
return 0; return 0;
} }
@ -335,9 +328,7 @@ static void join_game(void) {
int i; int i;
int sel = -1; int sel = -1;
if (!searchgames()) { if (!searchgames()) { return; }
return;
}
menuhistory[MENU_JOIN] = 0; menuhistory[MENU_JOIN] = 0;
@ -348,9 +339,7 @@ static void join_game(void) {
addexit("EXIT"); addexit("EXIT");
} else { } else {
additem("JOIN NETWORK GAME"); additem("JOIN NETWORK GAME");
for (i = 0; i < gamelistsize; i++) { for (i = 0; i < gamelistsize; i++) { additem(gamelistentries[i].name); }
additem(gamelistentries[i].name);
}
addexit("EXIT"); addexit("EXIT");
} }
sel = domenu(MENU_JOIN, join_game_pause); sel = domenu(MENU_JOIN, join_game_pause);
@ -358,12 +347,8 @@ static void join_game(void) {
} }
stop_search(); stop_search();
if(menuexit == sel || !gamelistsize) { if (menuexit == sel || !gamelistsize) { return; }
return; if (!tryjoin(sel)) { return; }
}
if(!tryjoin(sel)) {
return;
}
run_network_game(); run_network_game();
} }
@ -371,16 +356,16 @@ void mainloop(void) {
int sel; int sel;
exitflag = 0; exitflag = 0;
while(!exitflag) { while (!exitflag) {
menustart(); menustart();
additem("BOMBER MAIN MENU"); additem("BOMBER MAIN MENU");
additem("EXIT GAME"); additem("EXIT GAME");
additem("START SINGLE PLAYER GAME"); additem("START SINGLE PLAYER GAME");
additem("OPTIONS"); additem("OPTIONS");
// additem("REMAP MOVEMENT KEYS"); // additem("REMAP MOVEMENT KEYS");
additem("START NETWORK GAME"); additem("START NETWORK GAME");
additem("JOIN NETWORK GAME"); additem("JOIN NETWORK GAME");
sel=domenu(MENU_MAIN, NULL); sel = domenu(MENU_MAIN, NULL);
if (menudelta < 0) sel = -1; if (menudelta < 0) sel = -1;
switch (sel) { switch (sel) {
case 0: case 0:

337
src/network.c
View File

@ -1,34 +1,34 @@
#include "bomber.h" #include "network.h"
#include "announce.h" #include "announce.h"
#include "bomber.h"
#include "draw.h"
#include "game.h" #include "game.h"
#include "menu.h" #include "menu.h"
#include "network.h"
#include "utils.h" #include "utils.h"
#include "draw.h"
#define MAXMSG 4096 #define MAXMSG 4096
int udpsocket; int udpsocket;
const unsigned char gameversion[4]={0xda,0x01,0x00,0x09}; const unsigned char gameversion[4] = {0xda, 0x01, 0x00, 0x09};
struct netnode netnodes[MAXNETNODES]; struct netnode netnodes[MAXNETNODES];
static int informsize; static int informsize;
static unsigned char regpacket[64]; static unsigned char regpacket[64];
static struct sockaddr_in myname={0},mastername={0}; static struct sockaddr_in myname = {0}, mastername = {0};
static socklen_t senderlength; static socklen_t senderlength;
static struct sockaddr_in sender={0}; static struct sockaddr_in sender = {0};
static unsigned char mesg[MAXMSG]=""; static unsigned char mesg[MAXMSG] = "";
uchar needwhole=0; uchar needwhole = 0;
int mydatacount; int mydatacount;
int myslot; int myslot;
network_type network = NETWORK_NONE; network_type network = NETWORK_NONE;
int actioncount; int actioncount;
unsigned char actionblock[ACTIONHIST*MAXNETNODES]; unsigned char actionblock[ACTIONHIST * MAXNETNODES];
int myaction; int myaction;
unsigned char actions[MAXNETNODES]; unsigned char actions[MAXNETNODES];
@ -38,7 +38,7 @@ long latestcounts[MAXNETNODES];
enum network_packet_types { enum network_packet_types {
PKT_ACK, /* perfect copy of packet received */ PKT_ACK, /* perfect copy of packet received */
/* join / host game */ /* join / host game */
/* slave -> master packets */ /* slave -> master packets */
PKT_JOIN, /* 4 bytes version #, 4 bytes joinunique #, 16 bytes name */ PKT_JOIN, /* 4 bytes version #, 4 bytes joinunique #, 16 bytes name */
PKT_QUIT, /* 4 bytes unique # */ PKT_QUIT, /* 4 bytes unique # */
@ -48,7 +48,7 @@ enum network_packet_types {
PKT_CONFIG, /* 4 bytes unique #, config */ PKT_CONFIG, /* 4 bytes unique #, config */
PKT_ACCEPT, /* 4 bytes join unique #, 132 bytes seed + unique #, config, slot info (see invite) */ PKT_ACCEPT, /* 4 bytes join unique #, 132 bytes seed + unique #, config, slot info (see invite) */
PKT_REJECT, /* 4 bytes join unique #, 4 bytes version #, 1: reason */ PKT_REJECT, /* 4 bytes join unique #, 4 bytes version #, 1: reason */
/* ingame actions */ /* ingame actions */
/* slave -> master packets */ /* slave -> master packets */
PKT_MYDATA, /* 4 bytes unique #,4 bytes frame #, 1 byte data */ PKT_MYDATA, /* 4 bytes unique #,4 bytes frame #, 1 byte data */
/* master -> slave packets */ /* master -> slave packets */
@ -65,10 +65,7 @@ enum reject_reason {
#define _REJECT_LAST REJECT_VERSION #define _REJECT_LAST REJECT_VERSION
const char *reject_reason_str[] = { const char* reject_reason_str[] = {"Server full", "Version mismatch"};
"Server full",
"Version mismatch"
};
/* all bytes stored MSB first */ /* all bytes stored MSB first */
@ -125,135 +122,126 @@ received will be answered with PKT_QUIT.
/* Network I/O, building/checking packets */ /* Network I/O, building/checking packets */
#if defined (TEST_LATENCY) #if defined(TEST_LATENCY)
#define NUMQ 512 #define NUMQ 512
struct message { struct message {
int time; int time;
struct sockaddr_in *to; struct sockaddr_in* to;
int tosize; int tosize;
unsigned char msg[512]; unsigned char msg[512];
int len; int len;
} message[NUMQ]={0}; } message[NUMQ] = {0};
outmsgs() { outmsgs() {
int i; int i;
for(i=0;i<NUMQ;++i) { for (i = 0; i < NUMQ; ++i) {
if(message[i].time) { if (message[i].time) {
--message[i].time; --message[i].time;
if(message[i].time) continue; if (message[i].time) continue;
sendto(udpsocket,message[i].msg,message[i].len,0, sendto(udpsocket, message[i].msg, message[i].len, 0, message[i].to, sizeof(struct sockaddr_in));
message[i].to,sizeof(struct sockaddr_in));
} }
} }
} }
#endif #endif
static int putmsg(struct sockaddr_in *toname,unsigned char *msg,int len) { static int putmsg(struct sockaddr_in* toname, unsigned char* msg, int len) {
int status; int status;
#if defined (TEST_LATENCY) #if defined(TEST_LATENCY)
int i; int i;
for(i=0;i<NUMQ;++i) { for (i = 0; i < NUMQ; ++i) {
if(!message[i].time) { if (!message[i].time) {
message[i].time=10; message[i].time = 10;
message[i].to=toname; message[i].to = toname;
memcpy(message[i].msg,msg,len); memcpy(message[i].msg, msg, len);
message[i].len=len; message[i].len = len;
break; break;
} }
} }
return 0; return 0;
#else #else
status=sendto(udpsocket,msg,len,0, status = sendto(udpsocket, msg, len, 0, (struct sockaddr*) toname, sizeof(struct sockaddr_in));
(struct sockaddr *)toname,sizeof(struct sockaddr_in));
return status; return status;
#endif #endif
} }
static int getmsg(int msec) { static int getmsg(int msec) {
int size; int size;
memset(&sender,0,sizeof(sender)); memset(&sender, 0, sizeof(sender));
senderlength=sizeof(sender); senderlength = sizeof(sender);
if(msec) { if (msec) {
struct timeval timeout; struct timeval timeout;
fd_set readfds; fd_set readfds;
int res; int res;
memset(&timeout,0,sizeof(timeout)); memset(&timeout, 0, sizeof(timeout));
timeout.tv_sec=msec/1000; timeout.tv_sec = msec / 1000;
timeout.tv_usec=(msec%1000)*1000; timeout.tv_usec = (msec % 1000) * 1000;
FD_ZERO(&readfds); FD_ZERO(&readfds);
FD_SET(udpsocket,&readfds); FD_SET(udpsocket, &readfds);
res=select(udpsocket+1,&readfds,0,0,&timeout); res = select(udpsocket + 1, &readfds, 0, 0, &timeout);
if(res<=0) return -1; if (res <= 0) return -1;
} }
size=recvfrom(udpsocket,mesg,MAXMSG,0, size = recvfrom(udpsocket, mesg, MAXMSG, 0, (struct sockaddr*) &sender, &senderlength);
(struct sockaddr *)&sender,&senderlength);
return size; return size;
} }
static int isvalidunique(unsigned char *p) { static int isvalidunique(unsigned char* p) {
return 0 == memcmp(p, &network_unique, 4); return 0 == memcmp(p, &network_unique, 4);
} }
static int isvalidversion(unsigned char *p) { static int isvalidversion(unsigned char* p) {
return 0 == memcmp(p, gameversion, 4); return 0 == memcmp(p, gameversion, 4);
} }
static unsigned char* writeuint32(unsigned char *p, Uint32 i) { static unsigned char* writeuint32(unsigned char* p, Uint32 i) {
p[0]=i>>24L; p[0] = i >> 24L;
p[1]=i>>16L; p[1] = i >> 16L;
p[2]=i>>8L; p[2] = i >> 8L;
p[3]=i; p[3] = i;
return p+4; return p + 4;
} }
static Uint32 readuint32(unsigned char *p) { static Uint32 readuint32(unsigned char* p) {
return (p[0]<<24L) | (p[1]<<16L) | (p[2]<<8) | p[3]; return (p[0] << 24L) | (p[1] << 16L) | (p[2] << 8) | p[3];
} }
static unsigned char* write_unique(unsigned char *p) { static unsigned char* write_unique(unsigned char* p) {
memcpy(p, &network_unique, 4); memcpy(p, &network_unique, 4);
return p + 4; return p + 4;
} }
static unsigned char* write_version(unsigned char *p) { static unsigned char* write_version(unsigned char* p) {
memcpy(p, &gameversion, 4); memcpy(p, &gameversion, 4);
return p + 4; return p + 4;
} }
static int isvalidmsg_from_slave() { static int isvalidmsg_from_slave() {
int i; int i;
void *host; void* host;
void *port; void* port;
if (!isvalidunique(mesg+1)) return -1; if (!isvalidunique(mesg + 1)) return -1;
host=&sender.sin_addr.s_addr; host = &sender.sin_addr.s_addr;
port=&sender.sin_port; port = &sender.sin_port;
for(i=1;i<MAXNETNODES;++i) for (i = 1; i < MAXNETNODES; ++i)
if(netnodes[i].used && if (netnodes[i].used && !memcmp(&netnodes[i].netname.sin_addr.s_addr, host, 4) && !memcmp(&netnodes[i].netname.sin_port, port, 2)) return i;
!memcmp(&netnodes[i].netname.sin_addr.s_addr,host,4) &&
!memcmp(&netnodes[i].netname.sin_port,port,2))
return i;
return -1; return -1;
} }
static int isvalidmsg_from_master() { static int isvalidmsg_from_master() {
if (sender.sin_family != mastername.sin_family if (sender.sin_family != mastername.sin_family || sender.sin_addr.s_addr != mastername.sin_addr.s_addr || sender.sin_port != mastername.sin_port) return 0;
|| sender.sin_addr.s_addr != mastername.sin_addr.s_addr
|| sender.sin_port != mastername.sin_port) return 0;
return 1; return 1;
} }
/* Handling game actions */ /* Handling game actions */
static void addactions(void) { static void addactions(void) {
memmove(actionblock+MAXNETNODES, actionblock, (ACTIONHIST-1)*MAXNETNODES); memmove(actionblock + MAXNETNODES, actionblock, (ACTIONHIST - 1) * MAXNETNODES);
memcpy(actionblock, actions, MAXNETNODES); memcpy(actionblock, actions, MAXNETNODES);
++actioncount; ++actioncount;
} }
@ -264,8 +252,8 @@ static void sendactions(int which) {
msg[0] = PKT_STEP; msg[0] = PKT_STEP;
write_unique(msg + 1); write_unique(msg + 1);
writeuint32(msg + 5, actioncount); writeuint32(msg + 5, actioncount);
memcpy(msg + 9, actionblock, MAXNETNODES*ACTIONHIST); memcpy(msg + 9, actionblock, MAXNETNODES * ACTIONHIST);
putmsg(&netnodes[which].netname, msg, MAXNETNODES*ACTIONHIST + 9); putmsg(&netnodes[which].netname, msg, MAXNETNODES * ACTIONHIST + 9);
} }
static void sendmine(int frame) { static void sendmine(int frame) {
@ -289,17 +277,15 @@ int networktraffic(void) {
case NETWORK_NONE: case NETWORK_NONE:
return -1; return -1;
case NETWORK_MASTER: case NETWORK_MASTER:
memcpy(actions,latestactions,MAXNETNODES); memcpy(actions, latestactions, MAXNETNODES);
actions[0]=myaction; actions[0] = myaction;
if (myaction == ACT_QUIT) { if (myaction == ACT_QUIT) {
for (i = 1; i < MAXNETNODES; ++i) { for (i = 1; i < MAXNETNODES; ++i) {
if (netnodes[i].used) if (netnodes[i].used) actions[i] = ACT_QUIT;
actions[i] = ACT_QUIT;
} }
} else { } else {
for (i = 1; i < MAXNETNODES; ++i) { for (i = 1; i < MAXNETNODES; ++i) {
if (netnodes[i].used) if (netnodes[i].used) actions[i] &= ACT_MASK; /* only keep direction */
actions[i] &= ACT_MASK; /* only keep direction */
} }
now = gtime(); now = gtime();
for (;;) { for (;;) {
@ -313,7 +299,7 @@ int networktraffic(void) {
if (length < 10) continue; if (length < 10) continue;
whosent = isvalidmsg_from_slave(); whosent = isvalidmsg_from_slave();
if (whosent <= 0) continue; if (whosent <= 0) continue;
count = readuint32(mesg+5); count = readuint32(mesg + 5);
if (count > latestcounts[whosent]) { if (count > latestcounts[whosent]) {
latestcounts[whosent] = count; latestcounts[whosent] = count;
actions[whosent] = (actions[whosent] & ~ACT_MASK) | mesg[9]; /* don't drop "action" keys */ actions[whosent] = (actions[whosent] & ~ACT_MASK) | mesg[9]; /* don't drop "action" keys */
@ -324,10 +310,9 @@ int networktraffic(void) {
addactions(); /* update action history block */ addactions(); /* update action history block */
for (i = 1; i < MAXNETNODES; ++i) { for (i = 1; i < MAXNETNODES; ++i) {
if(netnodes[i].used) { if (netnodes[i].used) {
sendactions(i); /* send actions to every active node */ sendactions(i); /* send actions to every active node */
if (actions[i] == ACT_QUIT) if (actions[i] == ACT_QUIT) netnodes[i].used = 0; /* remove disconnected clients */
netnodes[i].used = 0; /* remove disconnected clients */
} }
} }
return actioncount; return actioncount;
@ -361,37 +346,37 @@ int networktraffic(void) {
/* Handling socket init */ /* Handling socket init */
int winsock=0; int winsock = 0;
void getsocket(void) { void getsocket(void) {
int status; int status;
socklen_t slen = sizeof(myname); socklen_t slen = sizeof(myname);
#if defined(__WIN32__) || defined(WIN32) #if defined(__WIN32__) || defined(WIN32)
char dummydata[128]; char dummydata[128];
if(WSAStartup(0x0101,(void *)dummydata)) { if (WSAStartup(0x0101, (void*) dummydata)) {
printf("Windows dumped\n"); printf("Windows dumped\n");
exit(1); exit(1);
} }
winsock=1; winsock = 1;
#endif #endif
udpsocket=socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP); udpsocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(udpsocket==-1) { if (udpsocket == -1) {
perror("socket()"); perror("socket()");
exit(1); exit(1);
} }
memset(&myname,0,sizeof(myname)); memset(&myname, 0, sizeof(myname));
myname.sin_family=AF_INET; myname.sin_family = AF_INET;
myname.sin_addr.s_addr=htonl(INADDR_ANY); myname.sin_addr.s_addr = htonl(INADDR_ANY);
myname.sin_port=htons(0); myname.sin_port = htons(0);
status=bind(udpsocket,(struct sockaddr *) &myname,sizeof(myname)); status = bind(udpsocket, (struct sockaddr*) &myname, sizeof(myname));
if(-1 == status) { if (-1 == status) {
perror("bind()"); perror("bind()");
exit(1); exit(1);
} }
status = getsockname(udpsocket, (struct sockaddr *) &myname, &slen); status = getsockname(udpsocket, (struct sockaddr*) &myname, &slen);
if(-1 == status) { if (-1 == status) {
perror("getsockname()"); perror("getsockname()");
exit(1); exit(1);
} }
@ -399,7 +384,7 @@ char dummydata[128];
void freesocket(void) { void freesocket(void) {
#if defined(__WIN32__) || defined(WIN32) #if defined(__WIN32__) || defined(WIN32)
if(!winsock) return; if (!winsock) return;
WSACleanup(); WSACleanup();
#endif #endif
} }
@ -413,7 +398,7 @@ static unsigned char* write_inform(unsigned char* put) {
*put++ = 0xff; /* slot specific for each slave */ *put++ = 0xff; /* slot specific for each slave */
for (i = 0; i < MAXNETNODES; ++i) { for (i = 0; i < MAXNETNODES; ++i) {
if(!netnodes[i].used) continue; if (!netnodes[i].used) continue;
*put++ = i; *put++ = i;
memmove(put, netnodes[i].name, 16); memmove(put, netnodes[i].name, 16);
put += 16; put += 16;
@ -424,15 +409,15 @@ static unsigned char* write_inform(unsigned char* put) {
static void send_inform_all(unsigned char type) { static void send_inform_all(unsigned char type) {
int i; int i;
unsigned char *put = mesg; unsigned char* put = mesg;
*put++ = type; *put++ = type;
put = write_unique(put); put = write_unique(put);
put = write_inform(put); put = write_inform(put);
informsize = put-mesg; informsize = put - mesg;
for(i=1;i<MAXNETNODES;++i) { for (i = 1; i < MAXNETNODES; ++i) {
if(netnodes[i].used) { if (netnodes[i].used) {
mesg[5] = i; mesg[5] = i;
putmsg(&netnodes[i].netname, mesg, informsize); putmsg(&netnodes[i].netname, mesg, informsize);
} }
@ -448,36 +433,35 @@ static unsigned char* write_config(unsigned char* put) {
} }
static void build_config() { static void build_config() {
unsigned char *put; unsigned char* put;
put=mesg; put = mesg;
*put++=PKT_CONFIG; *put++ = PKT_CONFIG;
put = write_config(put); put = write_config(put);
informsize=put-mesg; informsize = put - mesg;
} }
static void send_config1(int which) { static void send_config1(int which) {
putmsg(&netnodes[which].netname,mesg,informsize); putmsg(&netnodes[which].netname, mesg, informsize);
} }
void send_config() { void send_config() {
int i; int i;
build_config(); build_config();
for (i = 1; i < MAXNETNODES; ++i) for (i = 1; i < MAXNETNODES; ++i)
if (netnodes[i].used) if (netnodes[i].used) send_config1(i);
send_config1(i);
} }
static void send_reject(struct sockaddr_in *toname, Uint32 network_join_unique, unsigned char reason) { static void send_reject(struct sockaddr_in* toname, Uint32 network_join_unique, unsigned char reason) {
mesg[0] = PKT_REJECT; mesg[0] = PKT_REJECT;
memcpy(mesg+1, &network_join_unique, sizeof(network_join_unique)); memcpy(mesg + 1, &network_join_unique, sizeof(network_join_unique));
write_version(mesg+5); write_version(mesg + 5);
mesg[9] = reason; mesg[9] = reason;
putmsg(toname,mesg,10); putmsg(toname, mesg, 10);
} }
static void send_accept(Uint32 network_join_unique) { static void send_accept(Uint32 network_join_unique) {
unsigned char *put = mesg; unsigned char* put = mesg;
*put++ = PKT_ACCEPT; *put++ = PKT_ACCEPT;
memcpy(put, &network_join_unique, sizeof(network_join_unique)); memcpy(put, &network_join_unique, sizeof(network_join_unique));
@ -485,15 +469,15 @@ static void send_accept(Uint32 network_join_unique) {
put = write_seed_unique(put); put = write_seed_unique(put);
put = write_config(put); put = write_config(put);
put = write_inform(put); put = write_inform(put);
putmsg(&sender,mesg,put-mesg); putmsg(&sender, mesg, put - mesg);
} }
int start_network_game() { int start_network_game() {
if(!registergame(playername, myname.sin_port, gameversion)) return 0; if (!registergame(playername, myname.sin_port, gameversion)) return 0;
memset(netnodes,0,sizeof(netnodes)); memset(netnodes, 0, sizeof(netnodes));
netnodes[0].used=1; netnodes[0].used = 1;
memmove(netnodes[0].name,playername,16); memmove(netnodes[0].name, playername, 16);
myslot=0; myslot = 0;
return 1; return 1;
} }
@ -512,13 +496,11 @@ void cancel_network_game() {
int i; int i;
mesg[0] = PKT_INVITE; mesg[0] = PKT_INVITE;
write_unique(mesg+1); write_unique(mesg + 1);
mesg[5] = 0xff; mesg[5] = 0xff;
for(i=1;i<MAXNETNODES;++i) { for (i = 1; i < MAXNETNODES; ++i) {
if(netnodes[i].used) { if (netnodes[i].used) { putmsg(&netnodes[i].netname, mesg, 6); }
putmsg(&netnodes[i].netname,mesg,6);
}
} }
} }
@ -528,18 +510,18 @@ int handle_joins() {
unsigned char temp[64]; unsigned char temp[64];
Uint32 network_join_unique = 0; Uint32 network_join_unique = 0;
size=getmsg(40); size = getmsg(40);
switch (*mesg) { switch (*mesg) {
case PKT_JOIN: case PKT_JOIN:
if (size < 25) return 0; if (size < 25) return 0;
memcpy(&network_join_unique, mesg+5, sizeof(network_join_unique)); memcpy(&network_join_unique, mesg + 5, sizeof(network_join_unique));
if (!isvalidversion(mesg+1)) { if (!isvalidversion(mesg + 1)) {
send_reject(&sender, network_join_unique, REJECT_VERSION); send_reject(&sender, network_join_unique, REJECT_VERSION);
return 0; return 0;
} }
break; break;
case PKT_QUIT: case PKT_QUIT:
if (size < 5 || !isvalidunique(mesg+1)) return 0; if (size < 5 || !isvalidunique(mesg + 1)) return 0;
break; break;
default: default:
return 0; return 0;
@ -556,37 +538,33 @@ int handle_joins() {
if (-1 == j) j = i; if (-1 == j) j = i;
continue; /* don't compare with unused host */ continue; /* don't compare with unused host */
} }
if(memcmp(&netnodes[i].netname.sin_addr.s_addr, if (memcmp(&netnodes[i].netname.sin_addr.s_addr, &sender.sin_addr.s_addr, 4)) continue;
&sender.sin_addr.s_addr,4)) continue; if (memcmp(&netnodes[i].netname.sin_port, &sender.sin_port, 2)) continue;
if(memcmp(&netnodes[i].netname.sin_port,
&sender.sin_port,2)) continue;
/* found host */ /* found host */
break; break;
} }
switch (*mesg) { switch (*mesg) {
case PKT_QUIT: case PKT_QUIT:
if(i < MAXNETNODES) /* if host found, reset entry */ if (i < MAXNETNODES) /* if host found, reset entry */
memset(netnodes+i,0,sizeof(struct netnode)); memset(netnodes + i, 0, sizeof(struct netnode));
/* send always ACK for QUITs */ /* send always ACK for QUITs */
*temp=PKT_ACK; *temp = PKT_ACK;
memmove(temp+1,mesg,5); memmove(temp + 1, mesg, 5);
putmsg(&sender,temp,6); putmsg(&sender, temp, 6);
break; break;
case PKT_JOIN: case PKT_JOIN:
if (i==MAXNETNODES && j==-1) { /* reject */ if (i == MAXNETNODES && j == -1) { /* reject */
send_reject(&sender, network_join_unique, REJECT_FULL); send_reject(&sender, network_join_unique, REJECT_FULL);
return 0; return 0;
} }
if(i==MAXNETNODES) i=j; if (i == MAXNETNODES) i = j;
memmove(&netnodes[i].netname.sin_addr.s_addr, memmove(&netnodes[i].netname.sin_addr.s_addr, &sender.sin_addr.s_addr, 4);
&sender.sin_addr.s_addr,4); memmove(&netnodes[i].netname.sin_port, &sender.sin_port, 2);
memmove(&netnodes[i].netname.sin_port, netnodes[i].netname.sin_family = AF_INET;
&sender.sin_port,2); netnodes[i].used = 1;
netnodes[i].netname.sin_family=AF_INET; memcpy(netnodes[i].name, mesg + 9, 16);
netnodes[i].used=1;
memcpy(netnodes[i].name,mesg+9,16);
netnodes[i].name[15] = '\0'; netnodes[i].name[15] = '\0';
send_accept(network_join_unique); send_accept(network_join_unique);
@ -597,18 +575,20 @@ int handle_joins() {
/* Client side */ /* Client side */
static int read_inform(unsigned char** pbuf, int *psize) { static int read_inform(unsigned char** pbuf, int* psize) {
unsigned char *buf = *pbuf; unsigned char* buf = *pbuf;
int size = *psize; int size = *psize;
int i; int i;
if (size < 1) return 0; if (size < 1) return 0;
myslot = *buf++; size--; myslot = *buf++;
size--;
if (0xff == myslot) return 1; if (0xff == myslot) return 1;
if (size < 1) return 0; if (size < 1) return 0;
while (0xff != *buf) { while (0xff != *buf) {
i = *buf++; size--; i = *buf++;
size--;
if (size < 17 || i >= MAXNETNODES) return 0; if (size < 17 || i >= MAXNETNODES) return 0;
netnodes[i].used = 1; netnodes[i].used = 1;
memcpy(netnodes[i].name, buf, 16); memcpy(netnodes[i].name, buf, 16);
@ -634,16 +614,16 @@ static void read_config(unsigned char* buf) {
/* returns 0=ignore packet,1=we're rejected,2=INVITE/CONFIG,3=BEGIN */ /* returns 0=ignore packet,1=we're rejected,2=INVITE/CONFIG,3=BEGIN */
int scaninvite(int msec) { int scaninvite(int msec) {
int size; int size;
unsigned char *take; unsigned char* take;
size = getmsg(msec); size = getmsg(msec);
if (size < 6) return 0; if (size < 6) return 0;
if (*mesg!=PKT_INVITE && *mesg!=PKT_BEGIN && *mesg!=PKT_CONFIG) return 0; if (*mesg != PKT_INVITE && *mesg != PKT_BEGIN && *mesg != PKT_CONFIG) return 0;
if (!isvalidmsg_from_master()) return 0; if (!isvalidmsg_from_master()) return 0;
if (!isvalidunique(mesg+1)) return 0; if (!isvalidunique(mesg + 1)) return 0;
take = mesg+5; take = mesg + 5;
size -= 5; size -= 5;
switch (*mesg) { switch (*mesg) {
@ -666,35 +646,35 @@ int scaninvite(int msec) {
} }
} }
int send_join(struct sockaddr_in *netname, char playername[16]) { int send_join(struct sockaddr_in* netname, char playername[16]) {
int size; int size;
long now; long now;
Uint32 join_unique = gtime(); Uint32 join_unique = gtime();
unsigned char *buf; unsigned char* buf;
mastername = *netname; mastername = *netname;
*regpacket=PKT_JOIN; *regpacket = PKT_JOIN;
write_version(regpacket + 1); write_version(regpacket + 1);
writeuint32(regpacket+5, join_unique); writeuint32(regpacket + 5, join_unique);
memcpy(regpacket+9, playername, 16); memcpy(regpacket + 9, playername, 16);
now=longtime(); now = longtime();
putmsg(&mastername,regpacket,1+4+4+16); putmsg(&mastername, regpacket, 1 + 4 + 4 + 16);
while(longtime()-now < 3) { while (longtime() - now < 3) {
if (0 == (size = getmsg(1000))) { if (0 == (size = getmsg(1000))) {
/* got no message, send join again */ /* got no message, send join again */
putmsg(&mastername,regpacket,1+4+4+16); putmsg(&mastername, regpacket, 1 + 4 + 4 + 16);
continue; continue;
} }
if (size < 5) continue; if (size < 5) continue;
if (readuint32(mesg+1) != join_unique) continue; if (readuint32(mesg + 1) != join_unique) continue;
switch (*mesg) { switch (*mesg) {
case PKT_ACCEPT: case PKT_ACCEPT:
if (size < 1+4+132+4+2) continue; if (size < 1 + 4 + 132 + 4 + 2) continue;
read_seed_unique(mesg + 5); read_seed_unique(mesg + 5);
read_config(mesg+137); read_config(mesg + 137);
buf = mesg+141; buf = mesg + 141;
size -= 141; size -= 141;
if (!read_inform(&buf,&size)) return 0; if (!read_inform(&buf, &size)) return 0;
return 2; return 2;
case PKT_REJECT: case PKT_REJECT:
if (size < 10 || mesg[9] > _REJECT_LAST) { if (size < 10 || mesg[9] > _REJECT_LAST) {
@ -716,14 +696,13 @@ void send_quit() {
int size; int size;
*regpacket = PKT_QUIT; *regpacket = PKT_QUIT;
write_unique(regpacket+1); write_unique(regpacket + 1);
now=longtime(); now = longtime();
while(longtime()-now<10) { while (longtime() - now < 10) {
putmsg(&mastername,regpacket,5); putmsg(&mastername, regpacket, 5);
size=getmsg(1000); size = getmsg(1000);
if(size<6) continue; if (size < 6) continue;
if(mesg[0] != PKT_ACK || mesg[1] != PKT_QUIT) continue; if (mesg[0] != PKT_ACK || mesg[1] != PKT_QUIT) continue;
if (isvalidunique(mesg+2)) if (isvalidunique(mesg + 2)) break;
break;
} }
} }

14
src/network.h
View File

@ -1,13 +1,11 @@
#ifndef NETWORK_H #ifndef NETWORK_H
#define NETWORK_H #define NETWORK_H
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
enum { enum { MAXNETNODES = 8 };
MAXNETNODES = 8
};
struct netnode { struct netnode {
struct sockaddr_in netname; struct sockaddr_in netname;
@ -22,7 +20,7 @@ extern struct netnode netnodes[MAXNETNODES];
void getsocket(void); void getsocket(void);
void freesocket(void); void freesocket(void);
int send_join(struct sockaddr_in *netname, char playername[16]); int send_join(struct sockaddr_in* netname, char playername[16]);
void send_config(); void send_config();
void send_quit(); void send_quit();
int scaninvite(int msec); int scaninvite(int msec);
@ -45,8 +43,8 @@ int networktraffic(void);
extern int mydatacount; extern int mydatacount;
extern int myslot; extern int myslot;
extern int actionput,actioncount; extern int actionput, actioncount;
extern unsigned char actionblock[ACTIONHIST*MAXNETNODES]; extern unsigned char actionblock[ACTIONHIST * MAXNETNODES];
extern int myaction; extern int myaction;
extern unsigned char actions[MAXNETNODES]; extern unsigned char actions[MAXNETNODES];

202
src/sound.c
View File

@ -1,9 +1,9 @@
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <SDL_audio.h> #include <SDL_audio.h>
#include <SDL_error.h> #include <SDL_error.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "sound.h" #include "sound.h"
@ -13,16 +13,16 @@
int sound_enabled = 1; int sound_enabled = 1;
static char dirlist[]=DATADIR; static char dirlist[] = DATADIR;
static int readsound(int num); static int readsound(int num);
#define NUMSOUNDS ((int)(sizeof(soundnames)/sizeof(char*))) #define NUMSOUNDS ((int) (sizeof(soundnames) / sizeof(char*)))
#define MIXMAX 16 #define MIXMAX 16
#define SOUND_QUIET -1 #define SOUND_QUIET -1
static const char *soundnames[] = { static const char* soundnames[] = {
"bomb1.raw", "bomb1.raw",
"power1.raw", "power1.raw",
"death.raw", "death.raw",
@ -31,9 +31,8 @@ static const char *soundnames[] = {
"power2.raw", "power2.raw",
}; };
typedef struct sample typedef struct sample {
{ char* data;
char *data;
int len; int len;
} sample; } sample;
@ -41,151 +40,140 @@ typedef struct sample
static sample samples[NUMSOUNDS]; static sample samples[NUMSOUNDS];
static int soundworking=0; static int soundworking = 0;
static int fragment; static int fragment;
// static int soundwrite,soundread; // static int soundwrite,soundread;
static int *soundbuffer; static int* soundbuffer;
static int soundbufferlen; static int soundbufferlen;
static unsigned char sndclip[8192]; static unsigned char sndclip[8192];
#define MAXSOUNDCOMMANDS 32 #define MAXSOUNDCOMMANDS 32
static char soundcommands[MAXSOUNDCOMMANDS]; static char soundcommands[MAXSOUNDCOMMANDS];
static int soundtake,soundput; static int soundtake, soundput;
static int sndplaying[MIXMAX],sndposition[MIXMAX]; static int sndplaying[MIXMAX], sndposition[MIXMAX];
static void fillaudio(void *udata,Uint8 *buffer,int len) static void fillaudio(void* udata, Uint8* buffer, int len) {
{ char com, *p;
char com,*p; int i, j, *ip;
int i,j,*ip; int which;
int which; (void) udata;
(void)udata;
while(soundtake!=soundput) while (soundtake != soundput) {
{ com = soundcommands[soundtake];
com=soundcommands[soundtake]; soundtake = (soundtake + 1) & (MAXSOUNDCOMMANDS - 1);
soundtake=(soundtake+1)&(MAXSOUNDCOMMANDS-1); if (com == SOUND_QUIET) {
if(com==SOUND_QUIET) {memset(sndposition,0,sizeof(sndposition));continue;} memset(sndposition, 0, sizeof(sndposition));
if(com<NUMSOUNDS) continue;
{ }
for(i=0;i<MIXMAX;++i) if (com < NUMSOUNDS) {
if(!sndposition[i]) for (i = 0; i < MIXMAX; ++i)
{ if (!sndposition[i]) {
sndposition[i]=1; sndposition[i] = 1;
sndplaying[i]=com; sndplaying[i] = com;
break; break;
} }
} }
} }
memset(soundbuffer,0,soundbufferlen); memset(soundbuffer, 0, soundbufferlen);
for(i=0;i<MIXMAX;++i) for (i = 0; i < MIXMAX; ++i) {
{ if (!sndposition[i]) continue;
if(!sndposition[i]) continue; which = sndplaying[i];
which=sndplaying[i]; if (sndposition[i] == samples[which].len) {
if(sndposition[i]==samples[which].len) sndposition[i] = 0;
{
sndposition[i]=0;
continue; continue;
} }
p=samples[which].data; p = samples[which].data;
if(!p) continue; if (!p) continue;
p+=len*(sndposition[i]++ -1); p += len * (sndposition[i]++ - 1);
ip=soundbuffer; ip = soundbuffer;
j=len; j = len;
while(j--) *ip++ += *p++; while (j--) *ip++ += *p++;
} }
j=len; j = len;
ip=soundbuffer;; ip = soundbuffer;
while(j--) *buffer++ = sndclip[4096+*ip++]; ;
while (j--) *buffer++ = sndclip[4096 + *ip++];
} }
int soundopen(void) { int soundopen(void) {
SDL_AudioSpec wanted; SDL_AudioSpec wanted;
int i,j; int i, j;
soundtake=soundput=0; soundtake = soundput = 0;
memset(sndposition,0,sizeof(sndposition)); memset(sndposition, 0, sizeof(sndposition));
memset(sndplaying,0,sizeof(sndplaying)); memset(sndplaying, 0, sizeof(sndplaying));
fragment=SNDFRAGMENT<<1; fragment = SNDFRAGMENT << 1;
soundbufferlen=fragment*sizeof(int); soundbufferlen = fragment * sizeof(int);
soundbuffer=malloc(soundbufferlen); soundbuffer = malloc(soundbufferlen);
if(!soundbuffer) return -2; if (!soundbuffer) return -2;
memset(&wanted,0,sizeof(wanted)); memset(&wanted, 0, sizeof(wanted));
wanted.freq=22050; wanted.freq = 22050;
wanted.channels=2; wanted.channels = 2;
wanted.format=AUDIO_U8; wanted.format = AUDIO_U8;
wanted.samples=fragment>>1; wanted.samples = fragment >> 1;
wanted.callback=fillaudio; wanted.callback = fillaudio;
wanted.userdata=0; wanted.userdata = 0;
if(SDL_OpenAudio(&wanted,0)<0) if (SDL_OpenAudio(&wanted, 0) < 0) {
{ fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
fprintf(stderr,"Couldn't open audio: %s\n",SDL_GetError());
return -1; return -1;
} }
soundworking=1; soundworking = 1;
for(i=0;i<8192;i++) for (i = 0; i < 8192; i++) {
{ j = i - 4096;
j=i-4096; sndclip[i] = j > 127 ? 255 : (j < -128 ? 0 : j + 128);
sndclip[i]=j > 127 ? 255 : (j<-128 ? 0 : j+128);
} }
for(i=0;i<NUMSOUNDS;++i) for (i = 0; i < NUMSOUNDS; ++i) readsound(i);
readsound(i);
SDL_PauseAudio(0); SDL_PauseAudio(0);
return 0; return 0;
} }
void soundclose(void) { void soundclose(void) {
if(soundworking) if (soundworking) {
{
SDL_CloseAudio(); SDL_CloseAudio();
soundworking=0; soundworking = 0;
} }
} }
int readsound(int num) { int readsound(int num) {
char name[256],*p1,*p2,ch; char name[256], *p1, *p2, ch;
int file,size,len; int file, size, len;
p1=dirlist; p1 = dirlist;
for(;;) for (;;) {
{ p2 = name;
p2=name; while (*p1 && (ch = *p1++) != ',') *p2++ = ch;
while(*p1 && (ch=*p1++)!=',') if (p2 > name && p2[-1] != '/') *p2++ = '/';
*p2++=ch; strcpy(p2, soundnames[num]);
if(p2>name && p2[-1]!='/') *p2++='/'; file = open(name, O_RDONLY);
strcpy(p2,soundnames[num]); if (file >= 0) break;
file=open(name,O_RDONLY); if (!*p1) {
if(file>=0) break; samples[num].len = -1;
if(!*p1)
{
samples[num].len=-1;
return 0; return 0;
} }
} }
size=lseek(file,0,SEEK_END); size = lseek(file, 0, SEEK_END);
lseek(file,0,SEEK_SET); lseek(file, 0, SEEK_SET);
len=samples[num].len=(size+fragment-1)/fragment; len = samples[num].len = (size + fragment - 1) / fragment;
len*=fragment; len *= fragment;
p1=samples[num].data=malloc(len); p1 = samples[num].data = malloc(len);
if(p1) if (p1) {
{ read(file, p1, size);
read(file,p1,size); if (len - size) memset(p1 + size, 0, len - size);
if(len-size) memset(p1+size,0,len-size); while (size--) *p1++ ^= 0x80;
while(size--) *p1++ ^= 0x80;
} else } else
samples[num].data=0; samples[num].data = 0;
close(file); close(file);
return 0; return 0;
} }
void playsound(int n) { void playsound(int n) {
if (sound_enabled) { if (sound_enabled) {
soundcommands[soundput]=n; soundcommands[soundput] = n;
soundput=(soundput+1)&(MAXSOUNDCOMMANDS-1); soundput = (soundput + 1) & (MAXSOUNDCOMMANDS - 1);
} }
} }

73
src/utils.c
View File

@ -1,17 +1,17 @@
#include "bomber.h"
#include "utils.h" #include "utils.h"
#include "bomber.h"
#include "gfx.h" #include "gfx.h"
#include <arpa/inet.h> #include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h> #include <unistd.h>
int volatile hc=0; int volatile hc = 0;
char volatile interrupted=0; char volatile interrupted = 0;
static Uint32 cur_unique; static Uint32 cur_unique;
Uint32 network_unique; Uint32 network_unique;
@ -20,12 +20,12 @@ Uint32 gtime(void) {
} }
Uint32 longtime(void) { Uint32 longtime(void) {
return gtime()/1000; return gtime() / 1000;
} }
/* surf random generator: x (Daniel J. Bernstein) */ /* surf random generator: x (Daniel J. Bernstein) */
#define ROT(x, b) (((x) << (b)) | ((x) >> (32-(b)))) #define ROT(x, b) (((x) << (b)) | ((x) >> (32 - (b))))
#define MUSH(i, b) x = t[i] += (((x ^ seed[i]) + sum) ^ ROT(x,b)) #define MUSH(i, b) x = t[i] += (((x ^ seed[i]) + sum) ^ ROT(x, b))
static void surf(Uint32 out[8], const Uint32 in[12], const Uint32 seed[32]) { static void surf(Uint32 out[8], const Uint32 in[12], const Uint32 seed[32]) {
Uint32 t[12], x, sum = 0; Uint32 t[12], x, sum = 0;
int r, i, loop; int r, i, loop;
@ -35,11 +35,20 @@ static void surf(Uint32 out[8], const Uint32 in[12], const Uint32 seed[32]) {
for (loop = 0; loop < 2; ++loop) { for (loop = 0; loop < 2; ++loop) {
for (r = 0; r < 16; ++r) { for (r = 0; r < 16; ++r) {
sum += 0x9e3779b9; sum += 0x9e3779b9;
MUSH(0, 5); MUSH(1, 7); MUSH(2, 9); MUSH(3, 13); MUSH(0, 5);
MUSH(4, 5); MUSH(5, 7); MUSH(6, 9); MUSH(7, 13); MUSH(1, 7);
MUSH(8, 5); MUSH(9, 7); MUSH(10, 9); MUSH(11, 13); MUSH(2, 9);
MUSH(3, 13);
MUSH(4, 5);
MUSH(5, 7);
MUSH(6, 9);
MUSH(7, 13);
MUSH(8, 5);
MUSH(9, 7);
MUSH(10, 9);
MUSH(11, 13);
} }
for (i = 0; i < 8; ++i) out[i] ^= t[i+4]; for (i = 0; i < 8; ++i) out[i] ^= t[i + 4];
} }
} }
#undef ROT #undef ROT
@ -62,10 +71,14 @@ static Uint32 surf_init(void) {
if (-1 == fd) { if (-1 == fd) {
Uint32 genseed[4][8]; Uint32 genseed[4][8];
surf_seed[0] = surf_seed[1] = gtime(); surf_seed[0] = surf_seed[1] = gtime();
surf_in[0]++; surf(genseed[0], surf_in, surf_seed); surf_in[0]++;
surf_in[0]++; surf(genseed[1], surf_in, surf_seed); surf(genseed[0], surf_in, surf_seed);
surf_in[0]++; surf(genseed[2], surf_in, surf_seed); surf_in[0]++;
surf_in[0]++; surf(genseed[3], surf_in, surf_seed); surf(genseed[1], surf_in, surf_seed);
surf_in[0]++;
surf(genseed[2], surf_in, surf_seed);
surf_in[0]++;
surf(genseed[3], surf_in, surf_seed);
memcpy(surf_seed, genseed[0], 32); memcpy(surf_seed, genseed[0], 32);
memcpy(surf_seed, genseed[1], 32); memcpy(surf_seed, genseed[1], 32);
memcpy(surf_seed, genseed[2], 32); memcpy(surf_seed, genseed[2], 32);
@ -86,14 +99,15 @@ static Uint32 surf_init(void) {
static Uint32 surf_random(void) { static Uint32 surf_random(void) {
if (surf_left == 0) { if (surf_left == 0) {
int i; int i;
for (i = 0; (i < 12) && !(++surf_in[i]); i++) ; for (i = 0; (i < 12) && !(++surf_in[i]); i++)
;
surf_left = 8; surf_left = 8;
surf(surf_out, surf_in, surf_seed); surf(surf_out, surf_in, surf_seed);
} }
return surf_out[--surf_left]; return surf_out[--surf_left];
} }
void read_seed_unique(unsigned char *buf) { void read_seed_unique(unsigned char* buf) {
int i; int i;
memset(surf_in, 0, sizeof(surf_in)); memset(surf_in, 0, sizeof(surf_in));
@ -101,12 +115,12 @@ void read_seed_unique(unsigned char *buf) {
surf_left = 0; surf_left = 0;
memcpy(&surf_seed, buf, sizeof(surf_seed)); memcpy(&surf_seed, buf, sizeof(surf_seed));
memcpy(&network_unique, buf+sizeof(surf_seed), sizeof(network_unique)); memcpy(&network_unique, buf + sizeof(surf_seed), sizeof(network_unique));
cur_unique = ntohl(network_unique); cur_unique = ntohl(network_unique);
for (i = 0; i < 32; i++) surf_seed[i] = ntohl(surf_seed[i]); for (i = 0; i < 32; i++) surf_seed[i] = ntohl(surf_seed[i]);
} }
unsigned char* write_seed_unique(unsigned char *buf) { unsigned char* write_seed_unique(unsigned char* buf) {
int i; int i;
for (i = 0; i < 32; i++) { for (i = 0; i < 32; i++) {
@ -200,34 +214,34 @@ Uint32 get_unique(void) {
} }
#endif #endif
void nomem(char *str) { void nomem(char* str) {
printf("No memory!!![%s]\n",str); printf("No memory!!![%s]\n", str);
exit(1); exit(1);
} }
int mypause(void) { int mypause(void) {
while(!interrupted) { while (!interrupted) {
pollinput(); pollinput();
SDL_Delay(1); SDL_Delay(1);
} }
interrupted=0; interrupted = 0;
return 1; return 1;
} }
static Uint32 sdlhandler(Uint32 time) { static Uint32 sdlhandler(Uint32 time) {
#if defined (SDL_LATENCY) #if defined(SDL_LATENCY)
outmsgs(); outmsgs();
#endif #endif
interrupted=1; interrupted = 1;
hc++; hc++;
return time; return time;
} }
void pulseon(void) { void pulseon(void) {
SDL_SetTimer(40,sdlhandler); SDL_SetTimer(40, sdlhandler);
} }
void hexdump(unsigned char *p, int len) { void hexdump(unsigned char* p, int len) {
int i; int i;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
if (15 == len % 16) if (15 == len % 16)
@ -235,6 +249,5 @@ void hexdump(unsigned char *p, int len) {
else else
fprintf(stderr, "0x%X ", p[i]); fprintf(stderr, "0x%X ", p[i]);
} }
if (i % 16) if (i % 16) fprintf(stderr, "\n");
fprintf(stderr, "\n");
} }

12
src/utils.h
View File

@ -1,6 +1,8 @@
#ifndef UTILS_H #ifndef UTILS_H
#define UTILS_H #define UTILS_H
#include <SDL.h>
Uint32 gtime(void); Uint32 gtime(void);
Uint32 longtime(void); Uint32 longtime(void);
@ -10,21 +12,21 @@ void set_unique(Uint32 unique);
Uint32 get_unique(void); Uint32 get_unique(void);
#endif #endif
#define SEED_UNIQUE_SIZE (32*4+4) #define SEED_UNIQUE_SIZE (32 * 4 + 4)
void read_seed_unique(unsigned char *buf); void read_seed_unique(unsigned char* buf);
unsigned char* write_seed_unique(unsigned char *buf); unsigned char* write_seed_unique(unsigned char* buf);
void create_seed_unique(void); void create_seed_unique(void);
extern Uint32 network_unique; extern Uint32 network_unique;
int myrand(void); int myrand(void);
void nomem(char *str); void nomem(char* str);
int mypause(void); int mypause(void);
void pulseon(void); void pulseon(void);
void hexdump(unsigned char *p, int len); void hexdump(unsigned char* p, int len);
extern volatile int hc; extern volatile int hc;
extern volatile char interrupted; extern volatile char interrupted;