diff --git a/include/Makefile.am b/include/Makefile.am
new file mode 100644
index 0000000..34f7915
--- /dev/null
+++ b/include/Makefile.am
@@ -0,0 +1,22 @@
+## Process this file with automake to produce Makefile.in
+
+## Created by Anjuta - will be overwritten
+## If you don't want it to overwrite it,
+## 	Please disable it in the Anjuta project configuration
+
+bomberclone_includedir = $(pkgincludedir)
+
+bomberclone_include_DATA = \
+	basic.h \
+	bomberclone.h \
+	chat.h \
+	font.h \
+	gamesrv.h \
+	gfx.h \
+	keybinput.h \
+	map.h \
+	network.h \
+	packets.h \
+	sysfunc.h
+
+EXTRA_DIST = $(bomberclone_include_DATA)
diff --git a/include/basic.h b/include/basic.h
new file mode 100644
index 0000000..fa5ed46
--- /dev/null
+++ b/include/basic.h
@@ -0,0 +1,245 @@
+/* $Id: basic.h,v 1.4 2003/09/23 20:28:24 stpohle Exp $ */
+/* basic types which we need everywhere */
+
+#ifndef _BC_BASIC_H_
+
+#define _BC_BASIC_H_
+
+#define GAME_SPECIAL_ITEMBOMB 20
+#define GAME_SPECIAL_ITEMFIRE 20
+#define GAME_SPECIAL_ITEMSHOE 20
+#define GAME_SPECIAL_ITEMDEATH 40
+#define GAME_SPECIAL_ITEMMIXED 20
+#define GAME_SPECIAL_ITEMSTRIGGER 3
+#define GAME_SPECIAL_ITEMSROW 3
+#define GAME_SPECIAL_ITEMSPUSH 2
+#define GAME_MAX_TUNNELS 4				// number of tunnel entrys
+#define GAME_TIMEOUT 30000		// game timeout 10min)
+#define GAME_TIMEOUTHURRY 3000	// game timeout for hurry and dropping mode (1min)
+#define GAME_TUNNEL_TO 50		/* wait 5 game cycls before move and show 
+								   player again */
+
+#define EXPLOSION_SAVE_DISTANCE 64
+#define SPECIAL_TRIGGER_TIMEOUT 15
+#define SPECIAL_TRIGGER_NUMUSE 5  // 0=unlimited
+#define SPECIAL_TRIGGER_TIME 25
+#define SPECIAL_ROW_TIME 30
+#define SPECIAL_PUSH_TIME 50
+
+#define START_BOMBS 1
+#define START_RANGE 2
+#define START_SPEED 16
+#define SPEEDMUL 1.2
+
+#define MAX_PLAYERS 8
+#define MAX_BOMBS 12
+#define MAX_RANGE 10
+#define MAX_SPEED 40
+#define MAX_BLITRECTS 4096
+#define MAX_STONESTODRAW 2048
+#define MAX_SERVERENTRYS 8      /* number of entrys in the server tab */
+#define MAX_GAMESRVENTRYS 255   /* number of entry which can be get */
+#define MAX_FIELDSIZE_X 51
+#define MAX_FIELDSIZE_Y 31
+#define MIN_FIELDSIZE_X 15
+#define MIN_FIELDSIZE_Y 9
+#define MAX_FIELDANIMATION 2048  /* number of points on the field to be animated exploding 
+									stoned or powerups*/
+
+#define EXPLOSIONTIMEOUT 20
+#define ANI_FIRETIMEOUT 2
+#define ANI_BOMBTIMEOUT 1
+#define ANI_PLAYERTIMEOUT 1
+#define ANI_PLAYERILLTIMEOUT 1
+#define ANI_STONETIMEOUT 5
+
+#define TIME_FACTOR 50
+#define BOMB_TIMEOUT 5
+#define IL_TIMEOUT 20
+
+#define LEN_PLAYERNAME 10
+#define LEN_SERVERNAME 41
+#define LEN_PORT 6
+#define LEN_GAMENAME 32
+#define LEN_PATHFILENAME 512
+#define LEN_FILENAME 64
+#define LEN_TILESETNAME 32
+
+#define DEFAULT_UDPPORT 11000
+#define DEFAULT_GMUDPPORT "11100"
+#define DEFAULT_GAMEMASTER "x.yz.to:11100"
+#define GAMESRV_TIMEOUT 2000    /* Timeout of the GameSrv_GetEntry */
+
+#define UDP_TIMEOUT 15000
+#define BUF_SIZE 1024
+
+#define MENU_BG_SHADE_DARK -64
+#define MENU_BG_SHADE_BRIGHT 64
+
+#define MW_IS_GFX_SELECT(__gfx_nr,__result) for (__result = (MAX_PLAYERS-1); (bman.players[__result].gfx_nr != __gfx_nr) && (__result >= 0); __result--);
+
+#include <SDL.h>
+
+enum _networkflags {
+	NETF_firewall = 1
+};
+
+
+enum _backgound {               // to load some diffrent logos.. 
+    BG_start = 0,
+    BG_net,
+    BG_conf
+};
+
+
+enum _gametype {
+    GT_single = 0,
+    GT_multi
+};
+
+
+enum _multitype {
+    MT_ptpm,                    // udp ptp master
+    MT_ptps                     // udp ptp client
+};
+
+
+enum _gamestate {
+    GS_startup = 0,
+    GS_quit,
+    GS_wait,                    // waiting for players to join
+    GS_update,
+    GS_ready,
+    GS_running
+};
+
+
+enum _maptype {
+	MAPT_random = -1, // random map
+	MAPT_normal = 0,  // a normal map
+	MAPT_tunnel,	  // a map with tunnels
+	
+	MAPT_max
+};
+
+
+enum _fieldtype {
+    FT_nothing = 0,             // Nothing in here
+    FT_stone,                   // Stones you can bomb away
+    FT_block,                   // Stones which can't bomb away
+	FT_tunnel,					// the tunnel item
+    FT_death,                   // The bad Powerup
+    FT_fire,                    // The fire Powerup
+    FT_bomb,                    // The bomb Powerup
+    FT_shoe,                    // The shoe Powerup
+    FT_mixed,                   // The mixed Powerup
+	FT_sp_trigger,				// The Triggered bomb Special
+	FT_sp_row,					// The bomb-row special
+	FT_sp_push,					// The push-boms special
+	FT_sp_moved,				// The moved-boms special
+	FT_sp_liquid,				// The liquid-bomb special
+    FT_max                      // just to know how many types there are
+};
+
+
+enum _poweruptypes {
+	PWUP_good = 0,
+	PWUP_bad,
+	PWUP_special,
+	PWUP_max
+};
+
+
+enum _specials {
+	SP_nothing=0,				// player has no special
+	SP_trigger,					// triggered bomb
+	SP_row,						// bomb row
+	SP_push,					// push bombs
+	SP_moved,					// moved bombs
+	SP_liquid,					// liquid bombs
+	
+	SP_max						// just to know how many types there are
+};
+
+
+
+enum _playerillnestype {
+    PI_keys = 0,                // switch keys
+    PI_range,                   // set exploding range to 1
+    PI_slow,                    // sets speed to 6
+    PI_fast,                    // sets speed to 150
+    PI_bomb,                    // player is dropping bombs permanently
+    PI_nobomb,                  // player cannot drop a bomb or only 1 bomb
+
+    PI_max                      // just to know what is the last number
+};
+
+
+enum _bombstate {
+    BS_off = 0,
+    BS_ticking,
+    BS_exploding,
+	BS_trigger
+};
+
+
+enum _bombmode {
+	BM_normal = 0,
+	BM_pushed,
+	BM_moving,
+	BM_liquid,
+	BM_kicked
+};
+
+
+enum _playerstateflags {
+    PSF_used = 1,               // Player Unused  | Player Used
+    PSF_net = 2,                // Local Player   | AI / Network Player
+    PSF_alife = 4,              // Player is Dead  | Player is Alife
+    PSF_playing = 8,            // Watching Player  | Playing Player -- as long as one don't delete
+};
+
+#define PSFM_used (PSF_used + PSF_playing)
+#define PSFM_alife (PSF_used + PSF_alife + PSF_playing)
+#define PS_IS_dead(__ps) (((__ps) & (PSFM_alife)) == (PSFM_used))
+#define PS_IS_alife(__ps) (((__ps) & (PSFM_alife)) == (PSFM_alife))
+#define PS_IS_netplayer(__ps) (((__ps) & (PSF_net)) != 0)
+#define PS_IS_playing(__ps) (((__ps) & (PSFM_used)) == (PSFM_used))
+#define PS_IS_used(__ps) (((__ps) & (PSFM_used)) != 0)
+
+enum _direction {               // to handle directions better
+    left = 0,
+    right,
+    up,
+    down
+};
+
+enum _dirbitmask { 			  // bit mask for the directions
+	DIRM_left = 1,
+	DIRM_right = 2,
+	DIRM_up = 4,
+	DIRM_down = 8,
+	DIRM_under = 16
+};
+
+enum _mapselection {
+	MAPS_select = 0,
+	MAPS_randmap,
+	MAPS_randgen
+};
+
+enum _mstatus {
+	MS_normal = 0,
+	MS_hurrywarn,
+	MS_hurry,      // mapsize will go down
+	MS_dropitems,  // alot of items will be droppen randomly into the game
+	
+	MS_max
+};
+
+struct {
+    Sint16 x;
+    Sint16 y;
+} typedef _point;
+
+#endif
diff --git a/include/bomberclone.h b/include/bomberclone.h
new file mode 100644
index 0000000..edf17d3
--- /dev/null
+++ b/include/bomberclone.h
@@ -0,0 +1,295 @@
+/* $Id: bomberclone.h,v 1.4 2003/09/23 20:28:24 stpohle Exp $ */
+/* bomberclone.h */
+
+#ifndef _BOMBERCLONE_H_
+#define _BOMBERCLONE_H_
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <time.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#ifdef _WIN32
+	#include <windows.h>
+	#include <winsock.h>
+	#include <sys/stat.h>
+	#ifndef S_ISDIR
+		#define S_ISDIR(a) ((a & _S_IFDIR) == _S_IFDIR)
+	#endif
+	#ifndef S_ISREG
+		#define S_ISREG(a) ((a & _S_IFREG) == _S_IFREG)
+	#endif
+#else
+	#include <sys/time.h>
+	#include <sys/socket.h>
+	#include <netinet/in.h>
+	#include <netdb.h>
+	#include <arpa/inet.h>
+	#include <unistd.h>
+	#include <sys/types.h>
+	#include <dirent.h>
+#endif
+#include <SDL.h>
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "basic.h"
+#include "map.h"
+#include "gfx.h"
+#include "font.h"
+#include "sound.h"
+#include "network.h"
+#include "sysfunc.h"
+#include "keybinput.h"
+
+struct {
+	int to;  // if (to > 0) the ilness is still working
+	int data;
+} typedef _playerilness;
+
+
+struct {
+    _point pos;					// lower byte = _X Higher Byte = FX
+    int firer[4];               // range of the fire for the fire for each direction
+    int firerst[4];             /* just save here where the direction was going to stop (-1) 
+								if the exp is still growing */
+    int to;                     // timeout in ms after dropping the bomb. (loops * 0.0005sec)
+    int frame;                  // frame of the animation
+    int frameto;                // timeout for the frame
+    unsigned char r;            // range of the bomb
+    unsigned char state;        // state of the bomb BS_*
+	unsigned char mode;			// mode of the bomb BM_*
+    int ex_nr;                  // explosion number
+	_point dest;				// destination to move the bomb to
+	int speed;					// bomb moving speed
+	
+} typedef _bomb;
+
+struct {
+	int type; 					// type of the special
+	int to;						// timeout
+	int numuse;					// num of uses left
+	int use;					/* currently used set by special_use 
+								   and deleted in special_loop */
+} typedef _special;
+
+struct {
+	_gfxplayer *gfx;			// pointer to the gfx information
+	int gfx_nr;					// number of the player GFX
+	
+    int frame;                  // step of the animation
+    int frameto;                // timeout for the animation
+
+	int illframe;
+	int illframeto;
+
+    _point pos;                 /* position (without the offset)
+								   _x = pos.x & 255; fx = pos.x >> 8; */
+    _point old;					// the old position
+	int tunnelto;			/* timeout for dont show and move player
+							   needed on the tunnel effect */
+	
+    signed char d;              // direction
+    signed char m;              // player is moving ?
+    signed char old_m;          // to save the old state..
+
+    int bombs_n;                // maximal number of bombs for the player
+	int bomb_lastex;			// number of the bomb which explode the last time
+    _bomb bombs[MAX_BOMBS];     // number of bombs who are ticking.
+    int range;                  // range of the bombs
+	int speed;					// how fast we can go (0 = slow, 1 = normal... 3 = fastest)
+	int speeddat;				// some data i need to do the speed thing
+	_playerilness ill[PI_max];  // all possible types
+	_special special;			// special the player has
+	
+    char name[LEN_PLAYERNAME];  // name oder name[0] == 0
+    unsigned char state;        // status of the player
+    signed char in_nr;          // number of the connected player entry
+
+    int points;                 // points
+	int wins;					// wins
+    signed char dead_by;        // player who killed this player
+	
+	_net_player net;			// holds all important network data
+} typedef _player;
+
+
+struct {
+	char name[255];
+} typedef _serverlist;
+
+
+struct {
+    char datapath[512];
+	
+    _player players[MAX_PLAYERS];
+    int p_nr;                   // Playernumber 0 if you host a game or the number of the one you are.
+
+    int last_ex_nr;             // number of the last explosion
+	int updatestatusbar;			// 1 if statusbar has to be updated
+    unsigned char gametype;
+    unsigned char multitype;
+    unsigned char state;
+	int init_timeout;			// gametimeout init value
+	int timeout;				// game timeout
+    char playername[LEN_PLAYERNAME];
+    int players_nr_s;           // number of players at the beginning
+    int players_nr;             // number of player who are alife
+	signed char lastwinner;		// number of the last winnet
+
+    int maxplayer;              // number of max players for the server
+
+    int sock;                   // the server socket
+    unsigned char net_ai_family;
+    char port[LEN_PORT];        // what port we're using
+    char servername[LEN_SERVERNAME + LEN_PORT + 2]; // holds the name of the current server
+    _serverlist serverlist[MAX_SERVERENTRYS]; // ** CONFIG name of the server we are connected to
+    char gamename[LEN_GAMENAME]; // this will hold the game name
+    char gamemaster[LEN_SERVERNAME + LEN_PORT + 2]; // ** CONFIG ... GameMaster Address
+	unsigned char firewall;
+	unsigned char notifygamemaster;
+	unsigned char broadcasted_chat;		// 1 if the chat should be send to the bc server
+	unsigned char askplayername;		// ask player for name at startup
+	
+	unsigned char ai_players;	// number of ai players
+	signed char debug; // 0 = off 1 = on
+} typedef _bomberclone;
+
+
+struct {
+    int index;
+    char text[255];
+	// int type; // could be visible / disabled / grayed ?? should avoid -2 trick
+} typedef _menu;
+
+
+struct {
+	signed char dir;
+	signed char bestdir;
+} typedef _airunaway;
+
+
+extern _bomberclone bman;
+extern Uint32 timestamp;
+extern int debug;
+
+// Game routines.. 
+extern void game_draw_info ();
+extern void game_loop ();
+extern void game_end ();
+extern void game_start();
+extern void game_showresult ();
+
+// everything is declared in field.c
+extern void draw_field ();
+extern void field_clear(int x, int y);
+extern void field_animation_add (int x, int y);
+extern void field_animation ();
+extern void field_loop ();
+extern void field_hurrysize ();
+extern void field_hurrydropitems ();
+extern int field_check_alldirs (int x, int y, int type);
+extern void draw_stone (int x, int y);
+extern void stonelist_add (int x, int y);
+extern void stonelist_del ();
+extern void stonelist_draw ();
+
+// everything what is declared in players.c
+extern int dead_playerani ();
+extern void draw_player (_player * player);
+extern void restore_players_screen ();
+extern void move_player (int pl_nr);
+extern int stepmove_player (int pl_nr);
+extern void player_drop_bomb (int pl_nr);
+extern void get_player_on (short int x, short int y, int pl_nr[]);
+extern void player_died (_player * player, signed char dead_by);
+extern void draw_players ();
+extern void player_animation (_player * player);
+extern int check_field (short int x, short int y);
+extern void player_calcstep (_player * pl);
+extern void player_calcpos ();
+extern void player_set_ilness (_player *p, int t);
+extern void player_clear_ilness (_player *p, int type);
+extern void player_ilness_loop (int pl_nr);
+extern void player_check_powerup (int p_nr);
+extern void player_set_gfx (_player *p, signed char gfx_nr);
+extern int player_findfreebomb (_player *player);
+extern int player_checkpos (int x, int y);
+extern inline int postofield (int pos);
+
+// for the bomb..
+extern int bomb_loop ();
+extern void bomb_explode (int p, int b, int net);
+extern inline void bomb_action (_bomb *bomb);
+extern void bomb_move (_bomb *bomb);
+extern void get_bomb_on (short int x, short int y, _point bombs[]);
+extern void draw_fire (int x, int y, int d, int frame);
+extern void do_explosion (int p, int b);
+extern void restore_explosion (_bomb * bomb);
+extern int explosion_check_field (int x, int y, int p, int b);
+
+// menus
+extern void draw_select (int select, _menu menu[], int x, int y);
+extern int menu_loop (char *menutitle, _menu menu[], int lastselect);
+extern void draw_menu (char *text, _menu menu[], int *x, int *y);
+extern void menu_get_text (char *title, char *text, int len);
+extern void menu_displaymessage (char *title, char *text);
+extern void menu_displaytext (char *title, char *text, Uint8 r, Uint8 g, Uint8 b);
+extern char *menu_dir_select (char *title, char *path, signed char dirflags);
+void menu_clearkeybuff();
+void draw_menubox (int x, int y);
+
+// configuration
+extern void configuration ();
+extern void game_init (int argc, char **argv);
+extern int ReadConfig();
+extern int WriteConfig();
+extern void ReadPrgArgs (int argc, char **argv);
+
+// debug.c
+extern void d_in_pl_detail (char *head);
+extern void d_playerdetail (char *head);
+extern void d_gamedetail (char *head);
+extern void d_printf (char *fmt,...);
+extern void d_bitprint (int bits, int nr);
+extern void d_fatal (char *fmt,...);
+
+
+// single.c
+extern void single_game_new ();
+extern void single_create_ai (int players);
+extern void	single_loop();
+extern void single_playergame ();
+extern void single_menu ();
+extern int single_select_player ();
+extern int ai_choosedir (int dir, int nearbomb, int oldpos);
+extern inline int ai_invertdir (int dir);
+extern inline int ai_checkpos (_player * pl, _point * pos);
+extern int ai_findnearbombs (_point pos);
+extern int ai_findbestbombdir (_point pos, int dir, int range);
+extern int ai_bombpoints (_point pos, int range);
+extern _airunaway ai_runawayfrom (_point p, int nearbomb, signed char norecursive);
+extern int ai_checkfield (int x, int y);
+extern int ai_easyrunaway (_point p);
+
+
+// special.c
+extern void special_use (int p_nr);
+extern void special_pickup (int p_nr, int s_type);
+extern void special_loop ();
+extern void special_clear (int p_nr);
+extern void special_push (int p_nr);
+extern void special_row (int p_nr);
+extern void special_trigger (int p_nr);
+extern void special_liquidmoved (int p_nr);
+
+extern void tileset_load (char *tileset);
+extern void tileset_random ();
+extern void tileset_free ();
+
+#endif
diff --git a/include/chat.h b/include/chat.h
new file mode 100644
index 0000000..31bfd97
--- /dev/null
+++ b/include/chat.h
@@ -0,0 +1,35 @@
+
+#ifndef _CHAT_H_
+#define _CHAT_H_
+
+#include "keybinput.h"
+
+#define CHAT_MAX_LINES 255
+#define CHAT_BG_SHADE_DARK -64
+#define CHAT_BG_SHADE_BRIGHT 64
+
+struct __chat {
+	SDL_Rect window;
+	signed char visible;
+	signed char changed;
+	SDL_Surface *oldscreen;
+	short int startline;
+	short int lastline;
+	struct {
+		char text[255];
+		int status;
+	} lines[CHAT_MAX_LINES];
+	signed char lineschanged;
+	_keybinput input;
+} typedef _chat;
+
+extern _chat chat;
+
+extern void chat_show (int x1, int y1, int x2, int y2);
+extern void chat_addline (char *text);
+extern void chat_addstatusline (char *text);
+extern void chat_loop (SDL_Event *event);
+extern void chat_drawbox ();
+extern void chat_cleanup ();
+
+#endif
diff --git a/include/font.h b/include/font.h
new file mode 100644
index 0000000..31081bf
--- /dev/null
+++ b/include/font.h
@@ -0,0 +1,23 @@
+#ifndef _FONT_H_
+
+#define _FONT_H_
+
+#include "basic.h"
+
+struct __font {
+	SDL_Surface *image;
+	SDL_Surface *raw;
+	_point size;
+} typedef _font;
+
+extern _point font_lastsize;
+extern _font font[3];
+
+extern void font_setcolor (unsigned char r, unsigned char g, unsigned char b, int size);
+extern void font_draw (int x, int y, char *text, int size);
+extern void font_gfxdraw (int x, int y, char *text, int size, int ypos);
+extern void font_drawbold (int x, int y, char *text, int size, int bold);
+extern void font_load ();
+extern void font_free ();
+
+#endif
diff --git a/include/gamesrv.h b/include/gamesrv.h
new file mode 100644
index 0000000..b3d7e46
--- /dev/null
+++ b/include/gamesrv.h
@@ -0,0 +1,36 @@
+/*
+	include file for the gamesrv.c file
+*/
+
+struct game_entry {
+    char host[LEN_SERVERNAME];
+    char port[LEN_PORT];
+    char name[LEN_GAMENAME];
+    struct _version {
+        unsigned char major;
+        unsigned char minor;
+        unsigned char sub;
+    } version;
+    signed char curplayers;
+    signed char maxplayers;
+    signed char ai_family;
+    unsigned char state;
+    unsigned char multitype;
+    unsigned char gametype;
+	struct _user {
+		char name[LEN_PLAYERNAME];
+		short int points;
+		short int wins;
+	} players[MAX_PLAYERS];
+};
+
+extern int gamesrv_findentry (char *host, char *port);
+extern int gamesrv_findfree ();
+extern int gamesrv_startudp ();
+extern int gamesrv_getglist ();
+extern void gamesrv_getserver ();
+extern void gamesrv_quit ();
+extern void gamesrv_browse ();
+extern void gamesrv_sendmode (int maxplayer, int curplayers);
+extern void gamesrv_sendchat (char *text);
+extern void gamesrv_playerinfo (struct game_entry *gse);
diff --git a/include/gfx.h b/include/gfx.h
new file mode 100644
index 0000000..0fc690f
--- /dev/null
+++ b/include/gfx.h
@@ -0,0 +1,103 @@
+/* $Id: gfx.h,v 1.3 2003/09/23 20:28:24 stpohle Exp $ */
+#ifndef _GFX_H_
+
+#define _GFX_H_
+
+#define SCALE_MAXRES 10000
+#define GFX_IMGSIZE 64
+#define GFX_IMGBIGSIZE 96
+#define GFX_PLAYERIMGSIZE_Y 128
+
+#include "basic.h"
+
+
+struct __gfxblit {
+	SDL_Rect srcr;
+	SDL_Surface *srci;
+	SDL_Rect destr;
+	SDL_Surface *desti;
+    int y;
+} typedef _gfxblit;
+
+
+struct __gfxani {
+	SDL_Surface *image;
+    int frames;                 // how many single frames (image -> heigh / (1.5 * gamestyle.height))
+	int w;						// size of a single frame
+	int h;
+} typedef _gfxani;
+
+
+struct __gfxplayer {
+	_gfxani ani;
+    _point offset;
+	_point smal_size;
+	SDL_Surface *smal_image;			// smal size of the animation
+} typedef _gfxplayer;
+
+
+struct __gfx {
+	SDL_Surface *screen;
+	_point res;		// resolution
+	_point block;	// block size
+	short int bpp;  // bits per pixel
+	
+    unsigned char fullscreen;
+
+	_point offset;    // where the game field starts
+	
+	_gfxplayer players[MAX_PLAYERS];
+	short int postab[256];  // table of points where we need to go to.
+	
+	_gfxani field[FT_max];  // the field animations
+	SDL_Surface *smal_special[FT_max - FT_sp_trigger];
+
+	_gfxani powerup[3];	// powerup field animation
+	_gfxani fire;       // fire (explostion)
+	_gfxani bomb;		// bomb animation
+	_gfxani ill;		// sick animation above the player
+	_gfxani dead;		// load the dead player animation
+	
+	_gfxani menuselect; // The Menu Select GFX (the bomb ?)
+	
+    SDL_Surface *logo;
+} typedef _gfx;
+
+extern _gfx gfx;
+
+
+// gfx.c
+extern void gfx_loaddata ();
+extern void redraw_logo (int x, int y, int w, int h);
+extern void draw_logo ();
+extern void gfx_init ();		// Load Base Image Data
+extern void gfx_shutdown ();
+extern void draw_shadefield (SDL_Surface *s, SDL_Rect *rec, int c);
+extern int gfx_locksurface (SDL_Surface *surface);
+extern void gfx_unlocksurface (SDL_Surface *surface);
+extern void redraw_logo_shaded (int x, int y, int w, int h, int c);
+extern void gfx_load_players (int sx, int sy);
+extern void gfx_free_players ();
+
+// gfxpixelimage.c
+extern void getRGBpixel (SDL_Surface *surface, int x, int y, int *R, int *G, int *B);
+extern Uint32 getpixel(SDL_Surface *surface, int x, int y);
+extern void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
+extern void scale (short int *dpattern, short int x, short int y);
+extern SDL_Surface *scale_image (SDL_Surface * orginal, int newx, int newy);
+extern void shade_pixel(SDL_Surface *s, int x, int y, int c);
+extern SDL_Surface *makegray_image (SDL_Surface *org);
+extern SDL_Surface *gfx_copyscreen (SDL_Rect *wnd);
+
+
+// gfxengine.c
+extern void gfx_blitdraw ();
+extern void gfx_blit (SDL_Surface *srci, SDL_Rect *srcr, SDL_Surface *desti, SDL_Rect *destr, int y);
+extern void gfx_blitsort ();
+extern inline void gfx_blitsortclear ();
+extern inline void gfx_blitupdaterectclear ();
+extern void gfx_blitupdaterectdraw ();
+extern void gfx_blitupdaterectadd (SDL_Rect *rect);
+
+#endif
+
diff --git a/include/keybinput.h b/include/keybinput.h
new file mode 100644
index 0000000..c9358e3
--- /dev/null
+++ b/include/keybinput.h
@@ -0,0 +1,15 @@
+
+#ifndef _KEYBINPUT_H_
+#define _KEYBINPUT_H_
+
+struct __keybinput {
+	char text[255];
+	short int curpos;
+	short int len;
+	char changed;
+} typedef _keybinput;
+
+extern void keybinput_new (_keybinput *ki);
+extern int keybinput_loop (_keybinput *ki, SDL_Event *event);
+
+#endif
diff --git a/include/map.h b/include/map.h
new file mode 100644
index 0000000..76e9e1f
--- /dev/null
+++ b/include/map.h
@@ -0,0 +1,62 @@
+/* $Id: map.h,v 1.3 2003/09/23 20:28:24 stpohle Exp $ */
+/* map.h */
+
+#ifndef _MAP_H_
+#define _MAP_H_
+
+struct __ex_field {
+	unsigned char count;
+	unsigned char frame;
+} typedef _ex_field;
+
+
+struct __field {
+    unsigned char type;
+	signed char mixframe;		// data for the mixed frame
+    Sint16 frame;               // frame (frame > 0 && FS_stone)
+    Sint32 frameto;             // frame to
+    unsigned char special;      // to save special stones, or the tunnel number
+    _ex_field ex[4];          	// count up every explosion there is on this field for ever direction
+    Sint32 ex_nr;               // number to identify the explosion.
+} typedef _field;
+
+
+struct __map {
+	_point size;			// dimension of the field
+
+    _field field[MAX_FIELDSIZE_X][MAX_FIELDSIZE_Y];
+	_point tunnel[GAME_MAX_TUNNELS];  // save the destination of the tunnel
+	unsigned char bfield[MAX_FIELDSIZE_X][MAX_FIELDSIZE_Y]; // will hold informations if ther is a bomb
+
+	char tileset [LEN_TILESETNAME];
+	signed char random_tileset;
+	char map [LEN_PATHFILENAME];
+	signed char map_selection;
+	signed char type;		// type of the map (MAPT_*);
+	unsigned char bombs;
+	unsigned char fire;
+	unsigned char shoes;
+	unsigned char mixed;
+	unsigned char death;
+	unsigned char sp_trigger;
+	unsigned char sp_push;
+	unsigned char sp_row;
+	unsigned char state; // state of the map
+} typedef _map;
+
+
+extern _map map;
+
+// mapmenu.c
+extern void mapmenu ();
+extern void mapinfo ();
+
+// map.c
+extern void map_random ();
+extern void map_genrandom ();
+extern void init_map_tileset();
+extern void map_new (char *filename);
+extern void map_set_playerposition (int usermap);
+extern void map_load (FILE * fmap);
+
+#endif
diff --git a/include/network.h b/include/network.h
new file mode 100644
index 0000000..7a3066d
--- /dev/null
+++ b/include/network.h
@@ -0,0 +1,126 @@
+/*
+network.h file... for everything what have to do with the network stuff 
+*/
+
+#include <SDL.h>
+
+#ifndef _NETWORK_H_
+#define _NETWORK_H_
+
+#define MAX_UDPDATA 1024
+#define PKG_RESENDCACHE_SIZE (64*1024)
+#define PKG_IN_INDEX_NUM 256
+#define RESENDCACHE_TIMEOUT 400
+#define RESENDCACHE_TIMEOUT_MENU 3000
+#define RESENDCACHE_RETRY 10
+#define DOWNLOAD_TIMEOUT 2000
+#define DYN_PKG_MAX_MISSING 4
+#define DYN_PKG_MIN_MISSING 1
+#define PKG_SENDSETOPT 2
+
+#define GT_MP_PTPM (bman.multitype == MT_ptpm && bman.gametype == GT_multi)
+#define GT_MP_PTPS (bman.multitype == MT_ptps && bman.gametype == GT_multi)
+#define GT_MP_PTP ((bman.multitype ==  MT_ptps || bman.multitype == MT_ptpm) && bman.gametype == GT_multi)
+
+#define GS_WAITRUNNING (bman.state == GS_wait || bman.state == GS_ready || bman.state == GS_running)
+
+#define NET_CANSEND(__pl) (( __pl == 0 || GT_MP_PTPM || (bman.players[__pl].net.flags & NETF_firewall) == 0))
+
+/* Little / Big Endian Convert */
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+	#define NTOH16(__i) s_swap16(__i)
+	#define HTON16(__i) s_swap16(__i)
+	#define NTOH32(__i) s_swap32(__i)
+	#define HTON32(__i) s_swap32(__i)
+#else
+    /* intel system */
+	#define NTOH16(__i) (__i)
+	#define HTON16(__i) (__i)
+	#define NTOH32(__i) (__i)
+	#define HTON32(__i) (__i)
+#endif
+
+#ifdef _WIN32
+#define _sockaddr sockaddr
+#else
+#define _sockaddr sockaddr_in6
+#endif
+
+struct __net_addr {  // this holds the network data
+	char host[LEN_SERVERNAME];
+	char port[LEN_PORT];
+	struct _sockaddr sAddr;
+	signed char pl_nr; // pl_nr so we know it in the pkgcahce.
+} typedef _net_addr;
+
+
+struct __net_pkgopt { /* this will hold all needed data for the packet
+						timeout function */
+    signed char send_to;  // sending packet data (playermove) on 0 it will be send
+    signed char send_set; // start value for the packet data option (dynamic set)
+	int to_2sec;		// how many unreached packets was send
+	Uint32 to_timestamp;
+} typedef _net_pkgopt;
+
+struct __net_player {
+	_net_addr addr;		// holds the address
+	int pingreq;   // just to send a ping and to save the number in here
+	int pingack;   // just to wait for an ping reply.. it will show up here
+	Uint32 timestamp;  // time of the last incoming package
+	signed char net_istep;
+	signed char net_status;
+	unsigned char flags;  // keep some flags.. like NETF_firewall
+	_net_pkgopt pkgopt;  // packet and network controll data
+} typedef _net_player;	
+
+
+// network menu
+extern void netmenu();
+extern void networkmenu_joingame ();
+extern void networkmenu_options ();
+extern void join_multiplayer_game ();
+extern void host_multiplayer_game ();
+extern void multiplayer_firstrun ();
+
+// network.c
+extern int network_server_port (char *server, char *host, int hostlen, char *port, int portlen);
+extern void network_shutdown ();
+extern int network_init ();
+extern int network_loop ();
+extern void net_change_playerid (int pl_nr, unsigned char senddata);
+extern void net_new_game ();
+extern void net_transmit_gamedata ();
+extern void net_game_send_player (int p_nr);
+extern void net_game_send_playermove (int p_nr, int mustsend);
+extern void net_game_send_bomb (int p, int b);
+extern void net_game_send_field (int x, int y);
+extern void net_game_send_special (int pl_nr, int ex_nr);
+extern void net_game_fillsockaddr ();
+extern void net_game_send_ill (int p_nr);
+extern void net_delplayer (int pl_nr);
+extern void draw_netupdatestate ();
+extern void net_send_servermode ();
+extern void net_send_players ();
+extern int net_check_timeout (int pl_nr);
+extern void net_dyn_pkgoption ();
+extern void net_send_chat (char *text, signed char notigamesrv);
+extern void net_send_mapinfo ();
+
+// multiwait.c
+extern void wait_for_players ();
+extern void mw_init ();
+extern void mw_shutdown ();
+extern void mw_draw_gfxselect (int selgfx);
+extern void mw_draw_status ();
+extern void mw_wait_for_connect ();
+extern void mw_draw_chat ();
+
+// udp.c
+extern char *dns_net_getip (char *host);
+extern int dns_filladdr (char *host, int hostlen, char *port, int portlen, int ai_family, struct _sockaddr *sAddr);
+extern int udp_get (int sock, char *text, int len, struct _sockaddr *sAddr, int ai_family);
+extern int udp_server (char *port, int ai_family);
+extern void udp_send (int sock, char *text, int len, struct _sockaddr *sAddr, int ai_family);
+extern void udp_close (int sock);
+
+#endif
diff --git a/include/packets.h b/include/packets.h
new file mode 100644
index 0000000..2a5e223
--- /dev/null
+++ b/include/packets.h
@@ -0,0 +1,322 @@
+/* network packets.. */
+
+enum _network_data {
+    PKG_error = 0,
+    PKG_pingreq,
+    PKG_pingack,
+	PKG_playerid,
+    PKG_servermode,
+    PKG_quit,
+    PKG_field,
+    PKG_playerdata,
+    PKG_bombdata,
+    PKG_getfield,
+    PKG_getplayerdata,
+    PKG_fieldline,
+    PKG_playerstatus,
+	PKG_pkgack,
+	PKG_playermove,
+	PKG_chat,
+	PKG_ill,
+	PKG_special,
+	PKG_mapinfo,
+	PKG_tunneldata,
+	
+	PKG_bcmservchat = 90
+};
+
+
+enum _pkgflags {
+	PKGF_ackreq = 1,
+	PKGF_ipv6 = 2
+};
+
+
+struct pkgheader {
+    unsigned char typ;
+	unsigned char flags;
+    Sint16 id;
+	Sint16 len;
+};
+
+
+struct pkg {
+	struct pkgheader h;
+    char data[0];
+};
+
+
+struct pkg_bcmservchat {
+	char typ;
+    char data[128];
+};
+
+
+struct pkg_tunneldata {
+	struct pkgheader h;
+	signed char tunnel_nr;
+	_point target;
+};
+
+
+struct pkg_pkgack {
+	struct pkgheader h;
+    char typ;
+	Sint16 id;
+};
+
+
+struct pkg_ping {
+	struct pkgheader h;
+    Sint32 data;
+};
+
+
+struct pkg_field {
+	struct pkgheader h;
+    unsigned char x;
+    unsigned char y;
+    _field field;
+};
+
+
+struct pkg_error {
+	struct pkgheader h;
+    unsigned char nr;
+    char text[128];
+};
+
+
+struct pkg_servermode {
+	struct pkgheader h;
+    unsigned char type;
+    unsigned char state;
+    unsigned char multitype;
+    unsigned char players;
+	unsigned char mapstate;
+    unsigned char maxplayer;
+	signed char last_winner;
+	signed char fieldsize_x;
+	signed char fieldsize_y;
+	char tileset[LEN_TILESETNAME];
+    signed char pl_nr;      /* if the server sends this to a client... 
+                               it will be the clients in_nr number 
+                               (-1) for not set */
+};
+
+
+struct pkg_playerid {
+	struct pkgheader h;
+    char name[LEN_PLAYERNAME];
+    char host[LEN_SERVERNAME];
+    char port[LEN_PORT];
+	signed char ver_major;		// Version
+	signed char ver_minor;		// Version
+	signed char ver_sub;		// Version
+	signed char pl_nr;			// Player Nummer
+	signed char gfx_nr;			// number of the graphic
+	signed char state;
+	Sint16 points;
+	Sint16 wins;
+	signed char netflags;
+};	
+
+
+struct pkg_playerdata {
+	struct pkgheader h;
+    signed char p_nr;			// Playernumber
+	Sint16 points;			// points
+	Sint16 wins;				// how many times we win
+	signed char gfx_nr;			// the gfx number we want to use
+    _point pos;
+    unsigned char bombs_n;
+    unsigned char range;
+    unsigned char state;
+    unsigned char d;
+    unsigned char frame;
+	signed char dead_by;
+};
+
+
+struct pkg_playermove {
+	struct pkgheader h;
+    signed char p_nr;
+	signed char m;
+	signed char d;
+	signed char speed;
+	Sint16 tunnelto;
+    _point pos;
+};
+
+
+struct pkg_bombdata {
+	struct pkgheader h;
+    unsigned char p_nr;
+    unsigned char b_nr;
+    Uint16 x;
+    Uint16 y;
+    unsigned char state;
+    unsigned char r;
+    Sint32 ex_nr;
+    Sint32 to;
+    Uint16 destx;
+    Uint16 desty;
+	Sint16 speed;
+};
+
+
+struct pkg_quit {
+	struct pkgheader h;
+    char host[LEN_SERVERNAME];
+    char port[LEN_PORT];
+};
+
+
+struct pkg_getfield {
+	struct pkgheader h;
+    signed char line;
+};
+
+
+struct pkg_playerstatus {
+	struct pkgheader h;
+    signed char pl_nr;
+    signed char net_istep;
+    signed char status;
+};
+
+
+struct pkg_fieldline {
+	struct pkgheader h;
+    signed char line;
+    unsigned char type[MAX_FIELDSIZE_X];
+    unsigned char special[MAX_FIELDSIZE_X];
+};
+
+
+struct pkg_ill {
+	struct pkgheader h;
+	signed char pl_nr;
+	Sint16 to[PI_max];
+};
+
+
+struct pkg_getplayerdata {
+	struct pkgheader h;
+    signed char pl_nr;
+};
+
+
+struct pkg_chat {
+	struct pkgheader h;
+	char text[128];
+};
+
+
+struct pkg_special {
+	struct pkgheader h;
+	signed char pl_nr;
+	Sint32 ex_nr;
+    unsigned char typ;
+};
+
+
+struct pkg_mapinfo {
+	struct pkgheader h;
+	char tileset[LEN_TILESETNAME];
+	char mapname[LEN_FILENAME];
+	unsigned char map_selection;
+	unsigned char bombs;
+	unsigned char shoes;
+	unsigned char fire;
+	unsigned char mixed;
+	unsigned char death;
+	unsigned char sp_trigger;
+	unsigned char sp_push;
+	unsigned char sp_row;
+	unsigned char size_x;
+	unsigned char size_y;
+};
+
+
+struct _rscache_entry {
+	signed char pl_nr;			// playernumber to whom this data should go
+	Sint16 len;				    // size of the entry
+	Uint32 timestamp;			// pointer to the timestamp
+	signed char retry;			// retry's how many times we tryed this
+	_net_addr addr;				// pointer to the address
+	struct pkg packet;          // pointer to the packet
+};	
+
+
+struct _resend_cache {
+	char *data;   				  // will hold the pointer to out cache
+	struct _rscache_entry *entry; // pointer to our data
+	Sint32 fill;                  // how much we have used
+};
+
+
+struct _inpkg_index {
+	signed char pl_nr;
+	unsigned char typ;
+	Sint16 id;
+};
+
+
+extern int do_error (struct pkg_error *data, _net_addr *addr);
+extern void do_playerid (struct pkg_playerid *p_id, _net_addr *addr);
+extern void do_servermode (struct pkg_servermode *s_mod, _net_addr *addr);
+extern void do_field (struct pkg_field *f_dat, _net_addr *addr);
+extern void do_ping (struct pkg_ping *p_dat, _net_addr *addr);
+extern void do_playerdata (struct pkg_playerdata *p_dat, _net_addr *addr);
+extern void do_playermove (struct pkg_playermove *p_dat, _net_addr *addr);
+extern void do_bombdata (struct pkg_bombdata *b_dat, _net_addr *addr);
+extern void do_quit (struct pkg_quit *q_dat, _net_addr *addr);
+extern void do_getfield (struct pkg_getfield *gf_dat, _net_addr *addr);
+extern void do_fieldline (struct pkg_fieldline *f_dat, _net_addr *addr);
+extern void do_getplayerdata (struct pkg_getplayerdata *gp_dat, _net_addr *addr);
+extern void do_playerstatus (struct pkg_playerstatus *gp_dat, _net_addr *addr);
+extern void do_pkgack (struct pkg_pkgack *p_ack, _net_addr *addr);
+extern void do_chat (struct pkg_chat *chat_pkg, _net_addr *addr);
+extern int do_pkg (struct pkg *packet, _net_addr *addr);
+extern void do_bcmservchat (struct pkg_bcmservchat *packet, _net_addr *addr);
+extern void do_ill (struct pkg_ill *ill_pkg, _net_addr *addr);
+extern void do_special (struct pkg_special *sp_pkg, _net_addr *addr);
+extern void do_mapinfo (struct pkg_mapinfo *map_pkg, _net_addr *addr);
+extern void do_tunneldata (struct pkg_tunneldata *tun_pkg, _net_addr *addr);
+
+extern void send_pkg (struct pkg *packet, _net_addr *addr);
+extern void send_playerid (_net_addr *addr, char *name, char *pladdr, char *plport, int p_nr, int gfx_nr, signed char netflags);
+extern void send_servermode (_net_addr *addr, int pl_nr);
+extern void send_error (_net_addr *addr, char *text);
+extern void send_field (_net_addr *addr, int x, int y, _field * field);
+extern void send_ping (_net_addr *addr, int data, unsigned char typ);
+extern void send_playerdata (_net_addr *addr, int p_nr, _player * pl);
+extern void send_playermove (_net_addr *addr, int p_nr, _player * pl);
+extern void send_bombdata (_net_addr *addr, int p, int b, _bomb * bomb);
+extern void send_quit (_net_addr *addr, char *plhost, char *plport);
+extern void send_getfield (_net_addr *addr, int line);
+extern void send_fieldline (_net_addr *addr, int line);
+extern void send_getplayerdata (_net_addr *addr, int pl);
+extern void send_playerstatus (_net_addr *addr, int pl_nr, int net_istep, int status);
+extern void send_pkgack (_net_addr *addr, unsigned char typ, short int id);
+extern void send_chat (_net_addr *addr, char *text);
+extern void send_ill (_net_addr *addr, int p_nr, _player *pl);
+extern void send_special (_net_addr *addr, int p_nr, int typ, int ex_nr);
+extern void send_mapinfo (_net_addr *addr);
+extern void send_tunneldata (_net_addr *addr, int tunnelnr, int x, int y);
+
+extern void fwd_pkg (struct pkg *packet, _net_addr *addr);
+
+extern int get_player_nr (char *host, char *port);
+extern int inpkg_check (unsigned char typ, short int id, _net_addr *addr);
+
+
+/* this functions will be defined in pkgcache.c */
+extern int rscache_add (_net_addr *addr, struct pkg *packet);
+extern void rscache_del ();
+extern int rscache_getpos (_net_addr *addr, unsigned char typ, short int id);
+extern int rscache_getcurlen ();
+extern void rscache_loop ();
+
+extern struct _resend_cache resend_cache;
diff --git a/include/sound.h b/include/sound.h
new file mode 100644
index 0000000..3f0177f
--- /dev/null
+++ b/include/sound.h
@@ -0,0 +1,49 @@
+/* $Id: sound.h,v 1.3 2003/09/23 20:28:24 stpohle Exp $ */
+/* include file for the sound */
+
+#ifndef _SOUND_H_
+#define _SOUND_H_
+
+#include "bomberclone.h"
+
+#if HAVE_SDL_MIXER
+#include <SDL_mixer.h>
+#else
+#define Mix_Chunk void
+#define Mix_Music void
+#endif
+
+enum _soundsample {
+	SND_dead = 0,
+	SND_explode,
+	SND_bombdrop,
+	
+	SND_max
+};
+
+struct __snd {
+	unsigned char inited;
+
+	Mix_Chunk *sample[SND_max]; // henqvist
+	Mix_Music *music; // henqvist
+
+    int audio_rate;
+    Uint16 audio_format;
+    int audio_channels;
+	signed char playmusic;
+	signed char playsound;
+	
+} typedef _snd;
+
+extern _snd snd;
+
+void snd_play(int samplenr);
+void snd_music_start();
+void snd_music_stop();
+void snd_init();
+void snd_load(char *tilesetname);
+void snd_free ();
+void snd_options ();
+void snd_shutdown ();
+
+#endif
diff --git a/include/sysfunc.h b/include/sysfunc.h
new file mode 100644
index 0000000..1cb6c0f
--- /dev/null
+++ b/include/sysfunc.h
@@ -0,0 +1,32 @@
+/* $Id: sysfunc.h,v 1.3 2003/09/23 20:28:24 stpohle Exp $ */
+/* include some system near functions */
+
+#ifndef _SYSFUNC_H_
+#define _SYSFUNC_H_
+
+#define MAX_DIRENTRYS 1024
+
+enum _dirflags {
+	DF_dir  = 1,
+	DF_file = 2
+};
+
+struct __direntry {
+	unsigned char flags;
+	char name[LEN_FILENAME];
+	struct __direntry *next;
+} typedef _direntry;
+
+extern void s_delay (int ms);
+extern int s_random (int maxnr);
+extern char *s_gethomedir ();
+extern int s_countbits (int nbomb, int nr);
+extern char* getfilename(char* path);
+
+extern inline Sint16 s_swap16 (Sint16 i);
+extern inline Sint32 s_swap32 (Sint32 i);
+
+extern _direntry *s_getdir (char *path);
+extern _direntry *s_dirfilter (_direntry *dirstart, signed char dirflags);
+
+#endif