From cb550444313d102d4a8f4add30f4e0c81e44a4fb Mon Sep 17 00:00:00 2001
From: stpohle <stpohle>
Date: Wed, 10 Sep 2003 21:32:21 +0000
Subject: [PATCH] Little and Big Endian Support the First Try

---
 bomberclone.prj |  12 ++
 src/basic.h     |   8 +-
 src/map.h       |   8 +-
 src/network.h   |  16 ++
 src/packets.c   | 434 +++++++++++++++++++++++++-----------------------
 src/packets.h   |  46 ++---
 src/pkgcache.c  |   8 +-
 src/sysfunc.c   |  31 +++-
 src/sysfunc.h   |   5 +-
 9 files changed, 323 insertions(+), 245 deletions(-)

diff --git a/bomberclone.prj b/bomberclone.prj
index a795af4..51e92c0 100644
--- a/bomberclone.prj
+++ b/bomberclone.prj
@@ -65,6 +65,18 @@ project.menu.need.terminal=0
 
 project.configure.options=
 anjuta.program.arguments=
+preferences.indent.automatic=1
+preferences.use.tabs=1
+preferences.indent.opening=0
+preferences.indent.closing=0
+preferences.tabsize=4
+preferences.indent.size=4
+preferences.autoformat.style=Custom style
+preferences.autoformat.custom.style=-br -brs -l100 -lc100 -lp -hnl -bc -nip -nce -ncdw -bli1 -i4 -ts1-bad -bap
+preferences.autoformat.disable=0
+preferences.debugger.command=gdb
+preferences.ui.designer=glade '$(project.name).glade'
+preferences.help.browser=devhelp -s '$(current.file.selection)'
 
 module.include.name=include
 module.include.type=
diff --git a/src/basic.h b/src/basic.h
index 8d3b455..9038b67 100644
--- a/src/basic.h
+++ b/src/basic.h
@@ -1,4 +1,4 @@
-/* $Id: basic.h,v 1.51 2003/09/04 20:18:21 stpohle Exp $ */
+/* $Id: basic.h,v 1.52 2003/09/10 21:32:22 stpohle Exp $ */
 /* basic types which we need everywhere */
 
 #ifndef _BC_BASIC_H_
@@ -78,6 +78,8 @@
 
 #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
 };
@@ -236,8 +238,8 @@ enum _mstatus {
 };
 
 struct __point {
-    short int x;
-    short int y;
+    Sint16 x;
+    Sint16 y;
 } typedef _point;
 
 #endif
diff --git a/src/map.h b/src/map.h
index 9fd7c75..1bcad66 100644
--- a/src/map.h
+++ b/src/map.h
@@ -1,4 +1,4 @@
-/* $Id: map.h,v 1.5 2003/08/29 22:04:19 stpohle Exp $ */
+/* $Id: map.h,v 1.6 2003/09/10 21:32:22 stpohle Exp $ */
 /* map.h */
 
 #ifndef _MAP_H_
@@ -13,11 +13,11 @@ struct __ex_field {
 struct __field {
     unsigned char type;
 	signed char mixframe;		// data for the mixed frame
-    short int frame;            // frame (frame > 0 && FS_stone)
-    int frameto;                // frame to
+    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
-    int ex_nr;                  // number to identify the explosion.
+    Sint32 ex_nr;               // number to identify the explosion.
 } typedef _field;
 
 
diff --git a/src/network.h b/src/network.h
index c27fa4c..7a3066d 100644
--- a/src/network.h
+++ b/src/network.h
@@ -2,6 +2,8 @@
 network.h file... for everything what have to do with the network stuff 
 */
 
+#include <SDL.h>
+
 #ifndef _NETWORK_H_
 #define _NETWORK_H_
 
@@ -24,6 +26,20 @@ network.h file... for everything what have to do with the network stuff
 
 #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
diff --git a/src/packets.c b/src/packets.c
index a9bc3a1..e87efe4 100644
--- a/src/packets.c
+++ b/src/packets.c
@@ -45,7 +45,7 @@ send_error (_net_addr * addr, char *text)
     strncpy (p_err.text, text, 127);
     p_err.h.typ = PKG_error;
     p_err.h.flags = 0;
-    p_err.h.len = sizeof (struct pkg_error);
+    p_err.h.len = HTON16 (sizeof (struct pkg_error));
     p_err.nr = 0;
 
     send_pkg ((struct pkg *) &p_err, addr);
@@ -85,8 +85,9 @@ do_playerid (struct pkg_playerid *p_id, _net_addr * addr)
         send_error (addr, text);
         return;
     }
-    d_printf ("do_playerid (From:%s:%s pl_nr=%d) Player(name:%s [%s:%s], pl_nr:%d)\n", addr->host,
-              addr->port, addr->pl_nr, p_id->name, p_id->host, p_id->port, p_id->pl_nr);
+    d_printf
+        ("do_playerid (From:%s:%s pl_nr=%d) Player(name:%s [%s:%s], pl_nr:%d)\n",
+         addr->host, addr->port, addr->pl_nr, p_id->name, p_id->host, p_id->port, p_id->pl_nr);
 
     /* As Server/Master Only change settings, or do ignore them if we are not in GS_wait */
     if (((GT_MP_PTPM && (bman.state == GS_wait && addr->pl_nr != -1)) || // PTPM change setting
@@ -115,8 +116,8 @@ do_playerid (struct pkg_playerid *p_id, _net_addr * addr)
         }
 
         if (GT_MP_PTPS) {
-            pl->points = p_id->points;
-            pl->wins = p_id->wins;
+            pl->points = NTOH16 (p_id->points);
+            pl->wins = NTOH16 (p_id->wins);
         }
     }
 
@@ -153,20 +154,21 @@ do_playerid (struct pkg_playerid *p_id, _net_addr * addr)
 
             strncpy (pl->net.addr.host, addr->host, LEN_SERVERNAME);
             strncpy (pl->net.addr.port, addr->port, LEN_PORT);
-            dns_filladdr (pl->net.addr.host, LEN_SERVERNAME, pl->net.addr.port, LEN_PORT,
-                          bman.net_ai_family, &pl->net.addr.sAddr);
+            dns_filladdr (pl->net.addr.host, LEN_SERVERNAME, pl->net.addr.port,
+                          LEN_PORT, bman.net_ai_family, &pl->net.addr.sAddr);
             pl->net.flags = p_id->netflags;
             pl->net.addr.pl_nr = i;
             bman.players_nr_s++;
 
             /* send to the new client the servermode and the complete playerlist */
             send_servermode (addr, i);
-			send_mapinfo (addr);
+            send_mapinfo (addr);
             for (j = 0; j < MAX_PLAYERS; j++)
                 if (bman.players[j].net.addr.host[0] != 0 || bman.players[j].name[0] != 0)
-                    send_playerid (addr, bman.players[j].name, bman.players[j].net.addr.host,
-                                   bman.players[j].net.addr.port, j, bman.players[j].gfx_nr,
-                                   bman.players[i].net.flags);
+                    send_playerid (addr, bman.players[j].name,
+                                   bman.players[j].net.addr.host,
+                                   bman.players[j].net.addr.port, j,
+                                   bman.players[j].gfx_nr, bman.players[i].net.flags);
 
             addr->pl_nr = i;
             for (j = 0, i = 0; i < bman.maxplayer; i++)
@@ -192,27 +194,27 @@ do_playerid (struct pkg_playerid *p_id, _net_addr * addr)
         net_change_playerid (addr->pl_nr, (GT_MP_PTPM));
 
     d_playerdetail ("*** PLAYER List ***");
-	
+
     bman.updatestatusbar = 1;
 };
 
 
 void
-send_playerid (_net_addr * addr, char *name, char *pladdr, char *plport, int pl_nr, int gfx_nr,
-               signed char netflags)
+send_playerid (_net_addr * addr, char *name, char *pladdr, char *plport,
+               int pl_nr, int gfx_nr, signed char netflags)
 {
     struct pkg_playerid p_id;
     int vmi,
       vma,
       vsu;
 
-    d_printf ("send_playerid SendTo: %s:%s (Name:%16s p_nr:%d)\n", addr->host, addr->port, name,
-              pl_nr);
+    d_printf ("send_playerid SendTo: %s:%s (Name:%16s p_nr:%d)\n", addr->host,
+              addr->port, name, pl_nr);
     sscanf (VERSION, "%d.%d.%d", &vma, &vmi, &vsu);
 
     p_id.h.typ = PKG_playerid;
     p_id.h.flags = PKGF_ackreq;
-    p_id.h.len = sizeof (struct pkg_playerid);
+    p_id.h.len = HTON16 (sizeof (struct pkg_playerid));
     p_id.ver_sub = vsu;
     p_id.ver_major = vma;
     p_id.ver_minor = vmi;
@@ -233,8 +235,8 @@ send_playerid (_net_addr * addr, char *name, char *pladdr, char *plport, int pl_
     p_id.pl_nr = pl_nr;
     p_id.gfx_nr = gfx_nr;
     if (pl_nr != -1) {
-        p_id.points = bman.players[pl_nr].points;
-        p_id.wins = bman.players[pl_nr].wins;
+        p_id.points = HTON16 (bman.players[pl_nr].points);
+        p_id.wins = HTON16 (bman.players[pl_nr].wins);
         p_id.state = bman.players[pl_nr].state;
     }
     else {
@@ -267,7 +269,7 @@ do_servermode (struct pkg_servermode *s_mod, _net_addr * addr)
         bman.gametype = GT_single;
 
     bman.state = s_mod->state;
-	map.state = s_mod->mapstate;
+    map.state = s_mod->mapstate;
     if (s_mod->multitype == MT_ptpm)
         bman.multitype = MT_ptps;
 
@@ -279,8 +281,8 @@ do_servermode (struct pkg_servermode *s_mod, _net_addr * addr)
         map.size.y = s_mod->fieldsize_y;
     }
 
-	strncpy (map.tileset, s_mod->tileset, LEN_TILESETNAME);
-	
+    strncpy (map.tileset, s_mod->tileset, LEN_TILESETNAME);
+
     bman.updatestatusbar = 1;
 };
 
@@ -292,14 +294,14 @@ send_servermode (_net_addr * addr, int pl_nr)
     d_printf ("Send ServerMode\n");
 
     s_mod.h.typ = PKG_servermode;
-    s_mod.h.len = sizeof (struct pkg_servermode);
+    s_mod.h.len = HTON16 (sizeof (struct pkg_servermode));
     s_mod.h.flags = PKGF_ackreq;
     s_mod.type = bman.gametype;
-	s_mod.mapstate = map.state;
-	if (bman.state == GS_quit)    /* do not send GS_quit */
-		s_mod.state = GS_startup;
-	else
-		s_mod.state = bman.state;
+    s_mod.mapstate = map.state;
+    if (bman.state == GS_quit)  /* do not send GS_quit */
+        s_mod.state = GS_startup;
+    else
+        s_mod.state = bman.state;
     s_mod.multitype = bman.multitype;
     s_mod.players = bman.players_nr_s;
     s_mod.maxplayer = bman.maxplayer;
@@ -307,7 +309,7 @@ send_servermode (_net_addr * addr, int pl_nr)
     s_mod.last_winner = bman.lastwinner;
     s_mod.fieldsize_x = map.size.x;
     s_mod.fieldsize_y = map.size.y;
-	strncpy (s_mod.tileset, map.tileset, LEN_TILESETNAME);
+    strncpy (s_mod.tileset, map.tileset, LEN_TILESETNAME);
     send_pkg ((struct pkg *) &s_mod, addr);
 };
 
@@ -320,7 +322,7 @@ send_field (_net_addr * addr, int x, int y, _field * field)
     d_printf ("send_field [%d,%d]\n", x, y);
 
     f_dat.h.typ = PKG_field;
-    f_dat.h.len = sizeof (struct pkg_field);
+    f_dat.h.len = HTON16 (sizeof (struct pkg_field));
     f_dat.h.flags = PKGF_ackreq;
 
     f_dat.x = x;
@@ -341,16 +343,21 @@ do_field (struct pkg_field *f_dat, _net_addr * addr)
         return;
 
     if (f_dat->x < map.size.x && f_dat->y < map.size.y) {
+        /* convert the fielddata */
         memcpy (&map.field[f_dat->x][f_dat->y], &f_dat->field, sizeof (_field));
+        map.field[f_dat->x][f_dat->y].frame = NTOH16 (map.field[f_dat->x][f_dat->y].frame);
+        map.field[f_dat->x][f_dat->y].frameto = NTOH32 (map.field[f_dat->x][f_dat->y].frameto);
+        map.field[f_dat->x][f_dat->y].ex_nr = NTOH32 (map.field[f_dat->x][f_dat->y].ex_nr);
     }
     if (bman.state == GS_running)
         stonelist_add (f_dat->x, f_dat->y);
 
-    if (f_dat->field.ex_nr > bman.last_ex_nr)
-        bman.last_ex_nr = f_dat->field.ex_nr;
+    if (NTOH32 (f_dat->field.ex_nr) > bman.last_ex_nr)
+        bman.last_ex_nr = NTOH32 (f_dat->field.ex_nr);
 
-    d_printf ("do_field (%d,%d) ex_nr = %d, special = %d, type = %d\n", f_dat->x, f_dat->y,
-              f_dat->field.ex_nr, f_dat->field.special, f_dat->field.type);
+    d_printf ("do_field (%d,%d) ex_nr = %d, special = %d, type = %d\n",
+              f_dat->x, f_dat->y, NTOH32 (f_dat->field.ex_nr),
+              f_dat->field.special, f_dat->field.type);
 };
 
 
@@ -362,14 +369,14 @@ do_ping (struct pkg_ping *p_dat, _net_addr * addr)
 
     if (p_dat->h.typ == PKG_pingack)
         /* ping was an answer */
-        bman.players[addr->pl_nr].net.pingack = p_dat->data;
+        bman.players[addr->pl_nr].net.pingack = NTOH32 (p_dat->data);
 
     else
         /* send the answer */
-        send_ping (addr, p_dat->data, PKG_pingack);
+        send_ping (addr, NTOH32 (p_dat->data), PKG_pingack);
 
-    d_printf ("do_ping pl_nr[%d] (%s:%s)   req=%d, ack=%d\n", addr->pl_nr, addr->host,
-              addr->port, bman.players[addr->pl_nr].net.pingreq,
+    d_printf ("do_ping pl_nr[%d] (%s:%s)   req=%d, ack=%d\n", addr->pl_nr,
+              addr->host, addr->port, bman.players[addr->pl_nr].net.pingreq,
               bman.players[addr->pl_nr].net.pingack);
 };
 
@@ -382,23 +389,23 @@ send_ping (_net_addr * addr, int data, unsigned char typ)
     if (addr->pl_nr == -1)
         return;
 
-    p_dat.h.len = sizeof (struct pkg_ping);
+    p_dat.h.len = HTON16 (sizeof (struct pkg_ping));
     p_dat.h.flags = 0;
 
     if (typ == PKG_pingack) {
         p_dat.h.typ = typ;
-        p_dat.data = data;
+        p_dat.data = HTON32 (data);
         send_pkg ((struct pkg *) &p_dat, addr);
     }
 
     else if (typ == PKG_pingreq) {
         p_dat.h.typ = typ;
-        p_dat.data = data;
+        p_dat.data = HTON32 (data);
         send_pkg ((struct pkg *) &p_dat, addr);
     }
 
-    d_printf ("send_ping Player[%d] (%s:%s)   req=%d, ack=%d\n", addr->pl_nr, addr->host,
-              addr->port, bman.players[addr->pl_nr].net.pingreq,
+    d_printf ("send_ping Player[%d] (%s:%s)   req=%d, ack=%d\n", addr->pl_nr,
+              addr->host, addr->port, bman.players[addr->pl_nr].net.pingreq,
               bman.players[addr->pl_nr].net.pingack);
 
     bman.players[addr->pl_nr].net.timestamp = timestamp; /* we need to set it here, so we can check
@@ -412,22 +419,22 @@ send_playerdata (_net_addr * addr, int p_nr, _player * pl)
     struct pkg_playerdata p_dat;
 
     p_dat.h.typ = PKG_playerdata;
-    p_dat.h.len = sizeof (struct pkg_playerdata);
+    p_dat.h.len = HTON16 (sizeof (struct pkg_playerdata));
 
     if (bman.state == GS_update)
         p_dat.h.flags = 0;
     else
         p_dat.h.flags = PKGF_ackreq;
 
-    p_dat.pos.x = pl->pos.x;
-    p_dat.pos.y = pl->pos.y;
+    p_dat.pos.x = HTON16 (pl->pos.x);
+    p_dat.pos.y = HTON16 (pl->pos.y);
     p_dat.bombs_n = pl->bombs_n;
     p_dat.d = pl->d;
     p_dat.range = pl->range;
     p_dat.gfx_nr = pl->gfx_nr;
     p_dat.state = pl->state;
-    p_dat.wins = pl->wins;
-    p_dat.points = pl->points;
+    p_dat.wins = HTON16 (pl->wins);
+    p_dat.points = HTON16 (pl->points);
     p_dat.dead_by = pl->dead_by;
     p_dat.frame = pl->frame;
     p_dat.p_nr = p_nr;
@@ -454,14 +461,14 @@ do_playerdata (struct pkg_playerdata *p_dat, _net_addr * addr)
     player_set_gfx (pl, p_dat->gfx_nr);
 
     if (bman.state == GS_running && bman.p_nr != p_dat->p_nr) {
-        pl->points = p_dat->points;
-        pl->dead_by = p_dat->dead_by;
+        pl->points = NTOH16 (p_dat->points);
+        pl->dead_by = NTOH16 (p_dat->dead_by);
     }
     else if (bman.state != GS_running || bman.p_nr != p_dat->p_nr) {
-        pl->pos.x = p_dat->pos.x;
-        pl->pos.y = p_dat->pos.y;
+        pl->pos.x = NTOH16 (p_dat->pos.x);
+        pl->pos.y = NTOH16 (p_dat->pos.y);
         pl->dead_by = p_dat->dead_by;
-        pl->points = p_dat->points;
+        pl->points = NTOH16 (p_dat->points);
         pl->d = p_dat->d;
         pl->bombs_n = p_dat->bombs_n;
         pl->range = p_dat->range;
@@ -506,16 +513,16 @@ send_playermove (_net_addr * addr, int p_nr, _player * pl)
     struct pkg_playermove p_dat;
 
     p_dat.h.typ = PKG_playermove;
-    p_dat.h.len = sizeof (struct pkg_playermove);
+    p_dat.h.len = HTON16 (sizeof (struct pkg_playermove));
     p_dat.h.flags = 0;
 
-    p_dat.pos.x = pl->pos.x;
-    p_dat.pos.y = pl->pos.y;
+    p_dat.pos.x = HTON16 (pl->pos.x);
+    p_dat.pos.y = HTON16 (pl->pos.y);
     p_dat.m = pl->m;
     p_dat.d = pl->d;
     p_dat.p_nr = p_nr;
     p_dat.speed = pl->speed;
-	p_dat.tunnelto = pl->tunnelto;
+    p_dat.tunnelto = HTON16 (pl->tunnelto);
 
     send_pkg ((struct pkg *) &p_dat, addr);
 };
@@ -534,7 +541,7 @@ do_ill (struct pkg_ill *ill, _net_addr * addr)
         return;
 
     for (i = 0; i < PI_max; i++)
-        bman.players[ill->pl_nr].ill[i].to = ill->to[i];
+        bman.players[ill->pl_nr].ill[i].to = NTOH16 (ill->to[i]);
 };
 
 
@@ -546,12 +553,12 @@ send_ill (_net_addr * addr, int p_nr, _player * pl)
     int i;
 
     ill.h.typ = PKG_ill;
-    ill.h.len = sizeof (struct pkg_ill);
+    ill.h.len = HTON16 (sizeof (struct pkg_ill));
     ill.h.flags = PKGF_ackreq;
 
     ill.pl_nr = p_nr;
     for (i = 0; i < PI_max; i++)
-        ill.to[i] = pl->ill[i].to;
+        ill.to[i] = HTON16 (pl->ill[i].to);
 
     send_pkg ((struct pkg *) &ill, addr);
 };
@@ -576,9 +583,9 @@ do_playermove (struct pkg_playermove *p_dat, _net_addr * addr)
     pl->m = p_dat->m;
     pl->d = p_dat->d;
     pl->speed = p_dat->speed;
-    pl->pos.x = p_dat->pos.x;
-    pl->pos.y = p_dat->pos.y;
-	pl->tunnelto = p_dat->tunnelto;
+    pl->pos.x = HTON16 (p_dat->pos.x);
+    pl->pos.y = HTON16 (p_dat->pos.y);
+    pl->tunnelto = HTON16 (p_dat->tunnelto);
 }
 
 
@@ -598,8 +605,9 @@ do_bombdata (struct pkg_bombdata *b_dat, _net_addr * addr)
     if (b_dat->state == BS_off)
         return;                 // if there was a bomb let it explose don't delete the bomb
 
-    d_printf ("do_bombdata [%d,%d] Player: %d Bomb: %d, ex_nr:%d\n", b_dat->x, b_dat->y,
-              b_dat->p_nr, b_dat->b_nr, b_dat->ex_nr);
+    d_printf ("do_bombdata [%d,%d] Player: %d Bomb: %d, ex_nr:%d\n",
+              NTOH16 (b_dat->x) >> 8, NTOH16 (b_dat->y) >> 8, b_dat->p_nr,
+              b_dat->b_nr, NTOH32 (b_dat->ex_nr));
 
     bomb = &bman.players[b_dat->p_nr].bombs[b_dat->b_nr];
     if (bomb->state == BS_exploding) {
@@ -607,35 +615,35 @@ do_bombdata (struct pkg_bombdata *b_dat, _net_addr * addr)
         return;
     }
 
-    if ((bomb->pos.x != b_dat->x || bomb->pos.y != b_dat->y) && bomb->state == BS_exploding
-        && b_dat->state != BS_exploding)
+    if ((bomb->pos.x != NTOH16 (b_dat->x) || bomb->pos.y != NTOH16 (b_dat->y))
+        && bomb->state == BS_exploding && b_dat->state != BS_exploding)
         d_printf ("do_bombdata  WARNING : bomb explosion haven't finished\n");
 
     if (bomb->state != BS_off) { // handle push & kick special
-		map.bfield[(bomb->pos.x >> 8)][(bomb->pos.y >> 8)] = 0; //remove bomb at old location
+        map.bfield[(bomb->pos.x >> 8)][(bomb->pos.y >> 8)] = 0; //remove bomb at old location
         stonelist_add (bomb->pos.x >> 8, bomb->pos.y >> 8);
     }
 
     if (bomb->state == BS_off && (b_dat->state == BS_ticking || b_dat->state == BS_trigger))
         snd_play (SND_bombdrop);
-	
-    bomb->pos.x = b_dat->x;
-    bomb->pos.y = b_dat->y;
-	
-	if (bomb->state != b_dat->state && bomb->state != BS_ticking)
-		bomb->to = b_dat->to;  /* only set if the bomb isn't already ticking
-							      to make sure the timeout won't be resetted
-								  by an old network packet */
-	
-	map.bfield[bomb->pos.x >> 8][bomb->pos.y >> 8] = 1; // keep the bfield up to date
+
+    bomb->pos.x = NTOH16 (b_dat->x);
+    bomb->pos.y = NTOH16 (b_dat->y);
+
+    if (bomb->state != b_dat->state && bomb->state != BS_ticking)
+        bomb->to = NTOH32 (b_dat->to); /* only set if the bomb isn't already ticking
+                                          to make sure the timeout won't be resetted
+                                          by an old network packet */
+
+    map.bfield[bomb->pos.x >> 8][bomb->pos.y >> 8] = 1; // keep the bfield up to date
 
     bomb->r = b_dat->r;
-    bomb->ex_nr = b_dat->ex_nr;
+    bomb->ex_nr = NTOH32 (b_dat->ex_nr);
     bomb->state = b_dat->state & 0x0F;
-	bomb->mode = b_dat->state >> 4;
-	bomb->speed = b_dat->speed;
-	bomb->dest.x = b_dat->destx;
-	bomb->dest.y = b_dat->desty;
+    bomb->mode = b_dat->state >> 4;
+    bomb->speed = NTOH16 (b_dat->speed);
+    bomb->dest.x = NTOH16 (b_dat->destx);
+    bomb->dest.y = NTOH16 (b_dat->desty);
 
     if (bomb->state == BS_exploding)
         bomb_explode (b_dat->p_nr, b_dat->b_nr, 0);
@@ -651,66 +659,76 @@ send_bombdata (_net_addr * addr, int p, int b, _bomb * bomb)
     struct pkg_bombdata b_dat;
 
     b_dat.h.typ = PKG_bombdata;
-    b_dat.h.len = sizeof (struct pkg_bombdata);
-    b_dat.x = bomb->pos.x;
-    b_dat.y = bomb->pos.y;
-    b_dat.to = bomb->to;
+    b_dat.h.len = HTON16 (sizeof (struct pkg_bombdata));
+    b_dat.x = HTON16 (bomb->pos.x);
+    b_dat.y = HTON16 (bomb->pos.y);
+    b_dat.to = HTON32 (bomb->to);
     b_dat.r = bomb->r;
-    b_dat.ex_nr = bomb->ex_nr;
+    b_dat.ex_nr = HTON32 (bomb->ex_nr);
     b_dat.state = (bomb->mode << 4) | (bomb->state);
     b_dat.b_nr = b;
     b_dat.p_nr = p;
     b_dat.h.flags = PKGF_ackreq;
-	b_dat.speed = bomb->speed;
-	b_dat.destx = bomb->dest.x;
-	b_dat.desty = bomb->dest.y;
+    b_dat.speed = HTON16 (bomb->speed);
+    b_dat.destx = HTON16 (bomb->dest.x);
+    b_dat.desty = HTON16 (bomb->dest.y);
 
     send_pkg ((struct pkg *) &b_dat, addr);
 };
 
 /* recive a request for some tunneldata or receive tunneldata */
-void do_tunneldata (struct pkg_tunneldata *tun_pkg, _net_addr *addr) {
-	d_printf ("do_tunneldata: From %d [%s:%s] (Tunnel %d Target [%d,%d])\n", addr->pl_nr, addr->host, addr->port, tun_pkg->tunnel_nr, tun_pkg->target.x, tun_pkg->target.y);
-	
-	if (addr->pl_nr != 0 && GT_MP_PTPM && tun_pkg->target.y == -1 && tun_pkg->target.x == -1) {
-		send_tunneldata (addr, tun_pkg->tunnel_nr, map.tunnel[tun_pkg->tunnel_nr].x, map.tunnel[tun_pkg->tunnel_nr].y);
+void
+do_tunneldata (struct pkg_tunneldata *tun_pkg, _net_addr * addr)
+{
+    d_printf ("do_tunneldata: From %d [%s:%s] (Tunnel %d Target [%d,%d])\n",
+              addr->pl_nr, addr->host, addr->port, tun_pkg->tunnel_nr,
+              NTOH16 (tun_pkg->target.x), NTOH16 (tun_pkg->target.y));
+
+    if (addr->pl_nr != 0 && GT_MP_PTPM && NTOH16 (tun_pkg->target.y) == -1
+        && NTOH16 (tun_pkg->target.x) == -1) {
+        send_tunneldata (addr, tun_pkg->tunnel_nr,
+                         map.tunnel[tun_pkg->tunnel_nr].x, map.tunnel[tun_pkg->tunnel_nr].y);
         bman.players[addr->pl_nr].net.net_status = tun_pkg->tunnel_nr;
         bman.players[addr->pl_nr].net.net_istep = 3;
-	}
-	else if (addr->pl_nr == 0 && tun_pkg->tunnel_nr < GAME_MAX_TUNNELS) {
-		if (tun_pkg->target.x >= 0 && tun_pkg->target.x < map.size.x && tun_pkg->target.y >= 0 && tun_pkg->target.y < map.size.y) {
-			map.tunnel[tun_pkg->tunnel_nr].x = tun_pkg->target.x;
-			map.tunnel[tun_pkg->tunnel_nr].y = tun_pkg->target.y;
+    }
+    else if (addr->pl_nr == 0 && tun_pkg->tunnel_nr < GAME_MAX_TUNNELS) {
+        if (NTOH16 (tun_pkg->target.x) >= 0 && NTOH16 (tun_pkg->target.x) < map.size.x
+            && NTOH16 (tun_pkg->target.y) >= 0 && NTOH16 (tun_pkg->target.y) < map.size.y) {
+            map.tunnel[tun_pkg->tunnel_nr].x = NTOH16 (tun_pkg->target.x);
+            map.tunnel[tun_pkg->tunnel_nr].y = NTOH16 (tun_pkg->target.y);
             bman.players[bman.p_nr].net.net_status = tun_pkg->tunnel_nr;
-		}	
-		else 
-			d_printf ("              values out of range\n");
-	}
+        }
+
+        else
+            d_printf ("              values out of range\n");
+    }
 };
 
 
 /* send a tunneldata request (x && y == -1) or send tunneldata */
-void send_tunneldata (_net_addr *addr, int tunnelnr, int x, int y) {
-	struct pkg_tunneldata tun_pkg;
-
-	d_printf ("send_tunneldata (Tunnel %d Target [%d,%d])\n", tunnelnr, x, y);
-	
-	tun_pkg.h.typ = PKG_tunneldata;
-	tun_pkg.h.flags = PKGF_ackreq;
-	tun_pkg.h.len = sizeof (struct pkg_tunneldata);
-	
-	if ((GT_MP_PTPM && x != -1 && y != -1) || (GT_MP_PTPS && x == -1 && y == -1)) {
-		tun_pkg.tunnel_nr = tunnelnr;
-		tun_pkg.target.x = x;
-		tun_pkg.target.y = y;
-		
-		send_pkg ((struct pkg*) &tun_pkg, addr);
-	}
-};
+void
+send_tunneldata (_net_addr * addr, int tunnelnr, int x, int y)
+{
+    struct pkg_tunneldata tun_pkg;
+
+    d_printf ("send_tunneldata (Tunnel %d Target [%d,%d])\n", tunnelnr, x, y);
+
+    tun_pkg.h.typ = PKG_tunneldata;
+    tun_pkg.h.flags = PKGF_ackreq;
+    tun_pkg.h.len = HTON16 (sizeof (struct pkg_tunneldata));
 
+    if ((GT_MP_PTPM && x != -1 && y != -1)
+        || (GT_MP_PTPS && x == -1 && y == -1)) {
+        tun_pkg.tunnel_nr = tunnelnr;
+        tun_pkg.target.x = HTON16 (x);
+        tun_pkg.target.y = HTON16 (y);
+
+        send_pkg ((struct pkg *) &tun_pkg, addr);
+    }
+};
 
 void
-send_quit (_net_addr * addr, char *plhost, char *plport)
+send_quit (_net_addr * addr, char *plhost, char * plport)
 {
     struct pkg_quit q_dat;
 
@@ -718,13 +736,12 @@ send_quit (_net_addr * addr, char *plhost, char *plport)
 
     q_dat.h.typ = PKG_quit;
     q_dat.h.flags = 0;
-    q_dat.h.len = sizeof (struct pkg_quit);
+    q_dat.h.len = HTON16 (sizeof (struct pkg_quit));
 
     if (plhost == NULL) {
         q_dat.host[0] = 0;
         q_dat.port[0] = 0;
     }
-
     else {
         strncpy (q_dat.host, plhost, LEN_SERVERNAME);
         strncpy (q_dat.port, plport, LEN_PORT);
@@ -734,10 +751,12 @@ send_quit (_net_addr * addr, char *plhost, char *plport)
 };
 
 
+
 void
 do_quit (struct pkg_quit *q_dat, _net_addr * addr)
 {
     d_printf ("do_quit (%s:%s) pl_nr = %d\n", addr->host, addr->port, addr->pl_nr);
+
     if (addr->pl_nr == -1)
         return;
 
@@ -747,6 +766,7 @@ do_quit (struct pkg_quit *q_dat, _net_addr * addr)
     else {
         /* delete the player with the giving address */
         int pl_nr = get_player_nr (q_dat->host, q_dat->port);
+
         if (pl_nr == -1)
             return;
 
@@ -754,14 +774,13 @@ do_quit (struct pkg_quit *q_dat, _net_addr * addr)
     }
 };
 
-
 void
 send_getfield (_net_addr * addr, int line)
 {
     struct pkg_getfield gf_dat;
 
     gf_dat.h.typ = PKG_getfield;
-    gf_dat.h.len = sizeof (struct pkg_getfield);
+    gf_dat.h.len = HTON16 (sizeof (struct pkg_getfield));
     gf_dat.h.flags = 0;
     gf_dat.line = line;
     send_pkg ((struct pkg *) &gf_dat, addr);
@@ -783,7 +802,6 @@ do_getfield (struct pkg_getfield *gf_dat, _net_addr * addr)
             bman.players[addr->pl_nr].net.net_istep = 2;
         }
     }
-
     send_fieldline (addr, gf_dat->line);
 };
 
@@ -796,7 +814,7 @@ send_fieldline (_net_addr * addr, int line)
     struct pkg_fieldline f_dat;
 
     f_dat.h.typ = PKG_fieldline;
-    f_dat.h.len = sizeof (struct pkg_fieldline);
+    f_dat.h.len = HTON16 (sizeof (struct pkg_fieldline));
     f_dat.h.flags = 0;
     f_dat.line = line;
 
@@ -830,7 +848,6 @@ do_fieldline (struct pkg_fieldline *f_dat, _net_addr * addr)
         d_printf ("do_fieldline: the data we have got are not from the server\n");
         return;
     }
-
     if (f_dat->line < 0 || f_dat->line >= MAX_FIELDSIZE_Y) {
         /* the line number is wrong */
         d_printf ("do_fieldline: the line number is not correct\n");
@@ -843,8 +860,8 @@ do_fieldline (struct pkg_fieldline *f_dat, _net_addr * addr)
     for (i = 0; i < MAX_FIELDSIZE_X; i++) {
         map.field[i][f_dat->line].type = f_dat->type[i];
         map.field[i][f_dat->line].special = f_dat->special[i];
-		map.field[i][f_dat->line].frameto = 0;
-		map.field[i][f_dat->line].frame = 0;
+        map.field[i][f_dat->line].frameto = 0;
+        map.field[i][f_dat->line].frame = 0;
         for (d = 0; d < 4; d++)
             map.field[i][f_dat->line].ex[d].frame = map.field[i][f_dat->line].ex[d].count = 0;
     }
@@ -855,8 +872,9 @@ void
 send_getplayerdata (_net_addr * addr, int pl)
 {
     struct pkg_getplayerdata gp_dat;
+		
     gp_dat.h.typ = PKG_getplayerdata;
-    gp_dat.h.len = sizeof (struct pkg_getplayerdata);
+    gp_dat.h.len = HTON16 (sizeof (struct pkg_getplayerdata));
     gp_dat.pl_nr = pl;
     gp_dat.h.flags = 0;
     send_pkg ((struct pkg *) &gp_dat, addr);
@@ -894,9 +912,8 @@ do_playerstatus (struct pkg_playerstatus *stat, _net_addr * addr)
         d_printf ("do_playerstatus: the data we have got are not from the server\n");
         return;
     }
-
     if (stat->pl_nr < 0 || stat->pl_nr >= MAX_PLAYERS) {
-        /* the line number is wrong */
+        /* the player number is wrong */
         d_printf ("do_playerstatus: playernumber not correct\n");
         return;
     }
@@ -906,8 +923,8 @@ do_playerstatus (struct pkg_playerstatus *stat, _net_addr * addr)
     if (GT_MP_PTPM)
         for (i = 0; i < MAX_PLAYERS; i++)
             if (bman.players[i].net.addr.host[0] != 0)
-                send_playerstatus (&bman.players[i].net.addr, stat->pl_nr, stat->net_istep,
-                                   stat->status);
+                send_playerstatus (&bman.players[i].net.addr, stat->pl_nr,
+                                   stat->net_istep, stat->status);
 };
 
 
@@ -916,12 +933,12 @@ send_playerstatus (_net_addr * addr, int pl_nr, int net_istep, int status)
 {
     struct pkg_playerstatus stat;
 
-    d_printf ("send_playerstatus (%s,%s) %d, %d, %d\n", addr->host, addr->port, pl_nr, net_istep,
-              status);
+    d_printf ("send_playerstatus (%s,%s) %d, %d, %d\n", addr->host,
+              addr->port, pl_nr, net_istep, status);
 
     stat.h.typ = PKG_playerstatus;
     stat.h.flags = 0;
-    stat.h.len = sizeof (struct pkg_playerstatus);
+    stat.h.len = HTON16 (sizeof (struct pkg_playerstatus));
     stat.pl_nr = pl_nr;
     stat.net_istep = net_istep;
     stat.status = status;
@@ -948,7 +965,7 @@ send_chat (_net_addr * addr, char *text)
 
     chat_pkg.h.typ = PKG_chat;
     chat_pkg.h.flags = 0;
-    chat_pkg.h.len = sizeof (struct pkg_chat);
+    chat_pkg.h.len = HTON16 (sizeof (struct pkg_chat));
 
     for (i = 0; i < sizeof (chat_pkg.text); i++)
         chat_pkg.text[i] = 0;
@@ -965,8 +982,8 @@ send_pkgack (_net_addr * addr, unsigned char typ, short int id)
 
     p_ack.h.typ = PKG_pkgack;
     p_ack.h.flags = 0;
-    p_ack.h.len = sizeof (struct pkg_pkgack);
-    p_ack.id = id;
+    p_ack.h.len = HTON16 (sizeof (struct pkg_pkgack));
+    p_ack.id = HTON16 (id);
     p_ack.typ = typ;
 
     send_pkg ((struct pkg *) &p_ack, addr);
@@ -977,7 +994,7 @@ void
 do_pkgack (struct pkg_pkgack *p_ack, _net_addr * addr)
 {
     d_printf ("do_pkgack (%s:%s)\n", addr->host, addr->port);
-    if (rscache_getpos (addr, p_ack->typ, p_ack->id) == -1)
+    if (rscache_getpos (addr, p_ack->typ, NTOH16 (p_ack->id)) == -1)
         return;
 
     rscache_del ();
@@ -1000,7 +1017,7 @@ do_special (struct pkg_special *sp_pkg, _net_addr * addr)
         return;
 
     bman.players[sp_pkg->pl_nr].special.type = sp_pkg->typ;
-    bman.last_ex_nr = sp_pkg->ex_nr;
+    bman.last_ex_nr = NTOH32 (sp_pkg->ex_nr);
     special_use (sp_pkg->pl_nr);
 };
 
@@ -1011,11 +1028,11 @@ send_special (_net_addr * addr, int p_nr, int typ, int ex_nr)
     struct pkg_special sp_dat;
 
     sp_dat.h.typ = PKG_special;
-    sp_dat.h.len = sizeof (struct pkg_special);
+    sp_dat.h.len = HTON16 (sizeof (struct pkg_special));
     sp_dat.h.flags = PKGF_ackreq;
     sp_dat.pl_nr = p_nr;
     sp_dat.typ = typ;
-    sp_dat.ex_nr = ex_nr;
+    sp_dat.ex_nr = HTON32 (ex_nr);
     send_pkg ((struct pkg *) &sp_dat, addr);
 };
 
@@ -1027,10 +1044,10 @@ do_bcmservchat (struct pkg_bcmservchat *packet, _net_addr * addr)
     if (strstr (packet->data, "BC:BC:") == packet->data)
         return;                 // ignore packet
 
-	if (bman.notifygamemaster && bman.broadcasted_chat) {
-		chat_addline (packet->data);
-		net_send_chat (packet->data, 0);
-	}
+    if (bman.notifygamemaster && bman.broadcasted_chat) {
+        chat_addline (packet->data);
+        net_send_chat (packet->data, 0);
+    }
 };
 
 
@@ -1040,58 +1057,58 @@ send_mapinfo (_net_addr * addr)
     struct pkg_mapinfo map_pkg;
 
     map_pkg.h.typ = PKG_mapinfo;
-    map_pkg.h.len = sizeof (struct pkg_mapinfo);
+    map_pkg.h.len = HTON16 (sizeof (struct pkg_mapinfo));
     map_pkg.h.flags = PKGF_ackreq;
-	map_pkg.size_x = map.size.x;
-	map_pkg.size_y = map.size.y;
-	map_pkg.bombs = map.bombs;
-	map_pkg.fire = map.fire;
-	map_pkg.shoes = map.shoes;
-	map_pkg.mixed = map.mixed;
-	map_pkg.death = map.death;
-	map_pkg.sp_trigger = map.sp_trigger;
-	map_pkg.sp_row = map.sp_row;
-	map_pkg.sp_push = map.sp_push;
-	if (map.random_tileset)
-		map_pkg.tileset[0] = 0;
-	else
-		strcpy (map_pkg.tileset, map.tileset);
+    map_pkg.size_x = map.size.x;
+    map_pkg.size_y = map.size.y;
+    map_pkg.bombs = map.bombs;
+    map_pkg.fire = map.fire;
+    map_pkg.shoes = map.shoes;
+    map_pkg.mixed = map.mixed;
+    map_pkg.death = map.death;
+    map_pkg.sp_trigger = map.sp_trigger;
+    map_pkg.sp_row = map.sp_row;
+    map_pkg.sp_push = map.sp_push;
+    if (map.random_tileset)
+        map_pkg.tileset[0] = 0;
+    else
+        strcpy (map_pkg.tileset, map.tileset);
     map_pkg.map_selection = map.map_selection;
-	strcpy (map_pkg.mapname, map.map);
-	
-	send_pkg ((struct pkg *) &map_pkg, addr);
+    strcpy (map_pkg.mapname, map.map);
+
+    send_pkg ((struct pkg *) &map_pkg, addr);
 };
 
 
 void
 do_mapinfo (struct pkg_mapinfo *map_pkg, _net_addr * addr)
 {
-    d_printf ("do_mapinfo (addr %d) size[%d,%d]\n", addr->pl_nr,map_pkg->size_x,map_pkg->size_y);
+    d_printf ("do_mapinfo (addr %d) size[%d,%d]\n", addr->pl_nr, map_pkg->size_x, map_pkg->size_y);
 
-	/* check if the server send this information */
+    /* check if the server send this information */
     if (addr->pl_nr != 0)
         return;
 
-	if (map_pkg->tileset[0] == 0) {
-		map.random_tileset = 1;
-		map.tileset[0] = 0;
-	}
-	else {
-		map.random_tileset = 0;
-		strcpy(map.tileset, map_pkg->tileset);
-	}
-	strcpy (map.map, map_pkg->mapname);
-	map.map_selection = map_pkg->map_selection;
-	map.size.x = map_pkg->size_x;
-	map.size.y = map_pkg->size_y;
-	map.bombs = map_pkg->bombs;
-	map.fire = map_pkg->fire;
-	map.shoes = map_pkg->shoes;
-	map.mixed = map_pkg->mixed;
-	map.death = map_pkg->death;
-	map.sp_trigger = map_pkg->sp_trigger;
-	map.sp_push = map_pkg->sp_push;
-	map.sp_row = map_pkg->sp_row;
+    if (map_pkg->tileset[0] == 0) {
+        map.random_tileset = 1;
+        map.tileset[0] = 0;
+    }
+    else {
+        map.random_tileset = 0;
+        strcpy (map.tileset, map_pkg->tileset);
+    }
+    strcpy (map.map, map_pkg->mapname);
+    map.map_selection = map_pkg->map_selection;
+    map.size.x = map_pkg->size_x;
+    map.size.y = map_pkg->size_y;
+    map.bombs = map_pkg->bombs;
+    map.fire = map_pkg->fire;
+    map.shoes = map_pkg->shoes;
+    map.mixed = map_pkg->mixed;
+    map.death = map_pkg->death;
+    map.sp_trigger = map_pkg->sp_trigger;
+    map.sp_push = map_pkg->sp_push;
+    map.sp_row = map_pkg->sp_row;
 };
 
 
@@ -1115,7 +1132,6 @@ inpkg_check (unsigned char typ, short int id, _net_addr * addr)
         inpkg_index[inpkg_index_pos].typ = typ;
         inpkg_index[inpkg_index_pos].id = id;
     }
-
     return pos;
 };
 
@@ -1124,10 +1140,10 @@ inpkg_check (unsigned char typ, short int id, _net_addr * addr)
 void
 send_pkg (struct pkg *packet, _net_addr * addr)
 {
-    packet->h.id = pkg_lastid++;
+    packet->h.id = HTON16 (pkg_lastid++);
     if (bman.net_ai_family != PF_INET)
         packet->h.flags = packet->h.flags | PKGF_ipv6;
-    udp_send (bman.sock, (char *) packet, packet->h.len, &addr->sAddr, bman.net_ai_family);
+    udp_send (bman.sock, (char *) packet, NTOH16 (packet->h.len), &addr->sAddr, bman.net_ai_family);
 
     /* test if we have any important packet if so put it in the resend_cache */
     if (packet->h.flags & PKGF_ackreq) {
@@ -1136,6 +1152,7 @@ send_pkg (struct pkg *packet, _net_addr * addr)
     }
 };
 
+
 /* forward the packet to all who are behind a firewall */
 void
 fwd_pkg (struct pkg *packet, _net_addr * addr)
@@ -1152,8 +1169,8 @@ fwd_pkg (struct pkg *packet, _net_addr * addr)
         for (pl = 1; pl < MAX_PLAYERS; pl++)
             if (PS_IS_netplayer (bman.players[pl].state)
                 && ((bman.players[pl].net.flags & NETF_firewall) == NETF_firewall
-                    || (bman.players[addr->pl_nr].net.flags & NETF_firewall) == NETF_firewall)
-                && pl != addr->pl_nr)
+                    || (bman.players[addr->pl_nr].net.flags & NETF_firewall) ==
+                    NETF_firewall) && pl != addr->pl_nr)
                 send_pkg (packet, &bman.players[pl].net.addr);
 };
 
@@ -1161,13 +1178,12 @@ fwd_pkg (struct pkg *packet, _net_addr * addr)
 int
 do_pkg (struct pkg *packet, _net_addr * addr)
 {
-    if ((((packet->h.flags & PKGF_ipv6) == 0 && bman.net_ai_family != PF_INET) ||
-         ((packet->h.flags & PKGF_ipv6) != 0 && bman.net_ai_family == PF_INET)) &&
-        packet->h.typ != PKG_bcmservchat) {
+    if ((((packet->h.flags & PKGF_ipv6) == 0 && bman.net_ai_family != PF_INET)
+         || ((packet->h.flags & PKGF_ipv6) != 0 && bman.net_ai_family == PF_INET))
+        && packet->h.typ != PKG_bcmservchat) {
         d_printf ("-----packet comes from the wrong network type\n");
         return 0;
     }
-
     /* get the addr and set the ping timeout value */
     addr->pl_nr = get_player_nr (addr->host, addr->port);
     bman.players[addr->pl_nr].net.timestamp = timestamp;
@@ -1175,10 +1191,10 @@ do_pkg (struct pkg *packet, _net_addr * addr)
 
     /* test if we have any important packet */
     if (packet->h.flags & PKGF_ackreq && packet->h.typ != PKG_bcmservchat)
-        send_pkgack (addr, packet->h.typ, packet->h.id);
+        send_pkgack (addr, packet->h.typ, NTOH16 (packet->h.id));
 
     /* check the packet with the index */
-    if (packet->h.typ != PKG_bcmservchat && inpkg_check (packet->h.typ, packet->h.id, addr) != -1) {
+    if (packet->h.typ != PKG_bcmservchat && inpkg_check (packet->h.typ, NTOH16 (packet->h.id), addr) != -1) {
         /* we have got this packet already */
         d_printf ("-----packet ignored\n");
         if (addr->pl_nr >= 0 && addr->pl_nr < MAX_PLAYERS)
@@ -1187,7 +1203,7 @@ do_pkg (struct pkg *packet, _net_addr * addr)
     }
 
     /* check if the incoming packet have the right size */
-    if (packet->h.typ == PKG_servermode && packet->h.len != sizeof (struct pkg_servermode))
+    if (packet->h.typ == PKG_servermode && NTOH16 (packet->h.len) != sizeof (struct pkg_servermode))
         send_error (addr, "pkg_servermode: packetsize incorrect.");
 
     /* forward packet */
@@ -1253,12 +1269,12 @@ do_pkg (struct pkg *packet, _net_addr * addr)
     case (PKG_special):
         do_special ((struct pkg_special *) packet, addr);
         break;
-	case (PKG_mapinfo):
-		do_mapinfo ((struct pkg_mapinfo *) packet, addr);
-		break;
-	case (PKG_tunneldata):
-		do_tunneldata ((struct pkg_tunneldata *) packet, addr);
-		break;
+    case (PKG_mapinfo):
+        do_mapinfo ((struct pkg_mapinfo *) packet, addr);
+        break;
+    case (PKG_tunneldata):
+        do_tunneldata ((struct pkg_tunneldata *) packet, addr);
+        break;
     default:
         send_error (addr, "BomberClone: unknown data packet");
         break;
diff --git a/src/packets.h b/src/packets.h
index 149ddf5..2a5e223 100644
--- a/src/packets.h
+++ b/src/packets.h
@@ -35,8 +35,8 @@ enum _pkgflags {
 struct pkgheader {
     unsigned char typ;
 	unsigned char flags;
-    short int id;
-	short int len;
+    Sint16 id;
+	Sint16 len;
 };
 
 
@@ -62,13 +62,13 @@ struct pkg_tunneldata {
 struct pkg_pkgack {
 	struct pkgheader h;
     char typ;
-	short int id;
+	Sint16 id;
 };
 
 
 struct pkg_ping {
 	struct pkgheader h;
-    int data;
+    Sint32 data;
 };
 
 
@@ -116,8 +116,8 @@ struct pkg_playerid {
 	signed char pl_nr;			// Player Nummer
 	signed char gfx_nr;			// number of the graphic
 	signed char state;
-	short int points;
-	short int wins;
+	Sint16 points;
+	Sint16 wins;
 	signed char netflags;
 };	
 
@@ -125,8 +125,8 @@ struct pkg_playerid {
 struct pkg_playerdata {
 	struct pkgheader h;
     signed char p_nr;			// Playernumber
-	short int points;			// points
-	short int wins;				// how many times we win
+	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;
@@ -144,7 +144,7 @@ struct pkg_playermove {
 	signed char m;
 	signed char d;
 	signed char speed;
-	short int tunnelto;
+	Sint16 tunnelto;
     _point pos;
 };
 
@@ -153,15 +153,15 @@ struct pkg_bombdata {
 	struct pkgheader h;
     unsigned char p_nr;
     unsigned char b_nr;
-    unsigned short int x;
-    unsigned short int y;
+    Uint16 x;
+    Uint16 y;
     unsigned char state;
     unsigned char r;
-    int ex_nr;
-    int to;
-    unsigned short int destx;
-    unsigned short int desty;
-	signed short int speed;
+    Sint32 ex_nr;
+    Sint32 to;
+    Uint16 destx;
+    Uint16 desty;
+	Sint16 speed;
 };
 
 
@@ -197,7 +197,7 @@ struct pkg_fieldline {
 struct pkg_ill {
 	struct pkgheader h;
 	signed char pl_nr;
-	short int to[PI_max];
+	Sint16 to[PI_max];
 };
 
 
@@ -216,7 +216,7 @@ struct pkg_chat {
 struct pkg_special {
 	struct pkgheader h;
 	signed char pl_nr;
-	int ex_nr;
+	Sint32 ex_nr;
     unsigned char typ;
 };
 
@@ -241,25 +241,25 @@ struct pkg_mapinfo {
 
 struct _rscache_entry {
 	signed char pl_nr;			// playernumber to whom this data should go
-	short int len;				// size of the entry
+	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 pkg packet;          // pointer to the packet
 };	
 
 
 struct _resend_cache {
-	char *data;   				 // will hold the pointer to out cache
+	char *data;   				  // will hold the pointer to out cache
 	struct _rscache_entry *entry; // pointer to our data
-	int fill;                    // how much we have used
+	Sint32 fill;                  // how much we have used
 };
 
 
 struct _inpkg_index {
 	signed char pl_nr;
 	unsigned char typ;
-	short int id;
+	Sint16 id;
 };
 
 
diff --git a/src/pkgcache.c b/src/pkgcache.c
index cbc9f9b..88737a9 100644
--- a/src/pkgcache.c
+++ b/src/pkgcache.c
@@ -27,7 +27,7 @@ rscache_add (_net_addr * addr, struct pkg *packet)
     resend_cache.entry->retry = 0;
     resend_cache.entry->timestamp = timestamp;
     memcpy (&resend_cache.entry->addr, addr, sizeof (_net_addr));
-    memcpy (&resend_cache.entry->packet, packet, packet->h.len);
+    memcpy (&resend_cache.entry->packet, packet, NTOH16 (packet->h.len));
 
     newlen = resend_cache.fill + rscache_getcurlen ();
 
@@ -90,7 +90,7 @@ rscache_getpos (_net_addr * addr, unsigned char typ, short int id)
 
         if (strcmp (addr->host, resend_cache.entry->addr.host) == 0 &&
             strcmp (addr->port, resend_cache.entry->addr.port) == 0 &&
-            typ == resend_cache.entry->packet.h.typ && id == resend_cache.entry->packet.h.id)
+            typ == resend_cache.entry->packet.h.typ && id == NTOH16 (resend_cache.entry->packet.h.id))
             done = 1;           /* we have found the old packet */
         else
             pos = pos + len;
@@ -108,7 +108,7 @@ rscache_getcurlen ()
 {
     int len;
 
-    len = sizeof (struct _rscache_entry) - sizeof (struct pkg) + resend_cache.entry->packet.h.len;
+    len = sizeof (struct _rscache_entry) - sizeof (struct pkg) + NTOH16 (resend_cache.entry->packet.h.len);
 
     return len;
 };
@@ -137,7 +137,7 @@ rscache_loop ()
                  resend_cache.entry->addr.host, resend_cache.entry->addr.port, resend_cache.fill,
                  pos);
             udp_send (bman.sock, (char *) &resend_cache.entry->packet,
-                      resend_cache.entry->packet.h.len, &resend_cache.entry->addr.sAddr,
+                      NTOH16 (resend_cache.entry->packet.h.len), &resend_cache.entry->addr.sAddr,
                       bman.net_ai_family);
             resend_cache.entry->timestamp = timestamp;
             resend_cache.entry->retry++;
diff --git a/src/sysfunc.c b/src/sysfunc.c
index 321e88d..3828c87 100644
--- a/src/sysfunc.c
+++ b/src/sysfunc.c
@@ -1,4 +1,4 @@
-/* $Id: sysfunc.c,v 1.17 2003/07/15 11:43:09 stpohle Exp $
+/* $Id: sysfunc.c,v 1.18 2003/09/10 21:32:22 stpohle Exp $
     sysfunc.c - this file hold some routines for the system functions..
     like d_delay
 */
@@ -193,3 +193,32 @@ char* getfilename(char* path)
 			return path+i+1;
 	return path;
 }
+
+
+/* swap 16bit integers, needed for
+   little and big endian convert */
+inline Sint16 s_swap16 (Sint16 i) {
+	Sint16 r;
+	char *z1 = (char *)&i;
+	char *z2 = (char *)&r;
+	
+	*(z2+1) = *z1;
+	*z2 = *(z1+1);
+	
+	return r;
+};
+
+
+/* swap 32bit integers, needed for
+   little and big endian convert */
+inline Sint32 s_swap32 (Sint32 i) {
+	Sint32 r;
+	int j;
+	char *z1 = (char *) &i;
+	char *z2 = (char *) &r;
+	
+	for (j = 0; j < 4; j++)
+		*(z2+j) = *(z1+(3-j));
+	
+	return r;
+};
diff --git a/src/sysfunc.h b/src/sysfunc.h
index 3e908fa..a2f1d14 100644
--- a/src/sysfunc.h
+++ b/src/sysfunc.h
@@ -1,4 +1,4 @@
-/* $Id: sysfunc.h,v 1.7 2003/07/15 11:43:09 stpohle Exp $ */
+/* $Id: sysfunc.h,v 1.8 2003/09/10 21:32:22 stpohle Exp $ */
 /* include some system near functions */
 
 #ifndef _SYSFUNC_H_
@@ -23,6 +23,9 @@ 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);