diff -r f5c86420facd -r 2dbf40661580 src/Network/Packet.cc
--- a/src/Network/Packet.cc	Thu Dec 04 21:10:41 2008 +0000
+++ b/src/Network/Packet.cc	Thu Dec 04 21:59:23 2008 +0000
@@ -4,48 +4,10 @@
 
 #include "Packet.hh"
 
-
-NetworkPacket::NetworkPacket (void) :
-    buf_size(NETWORK_PACKET_SIZE), data_size(0), offset(0) {
-    
-    // nothing
-}
-
-void NetworkPacket::check_write_size (size_t item_size) {
-     if (offset + item_size > buf_size)
-        throw NetworkPacketError("not enough space to write");
-
-}
-        
-void NetworkPacket::check_read_size (size_t item_size) {
-    if (offset + item_size > data_size)
-        throw NetworkPacketError("not enough data to read");
-}
-
-void NetworkPacket::write (const void *ptr, size_t len) {
-    // check buffer overflow
-    check_write_size(len);
-
-    // set value
-    memcpy(buf + offset, ptr, len);
-
-    // update offset and size
-    offset += len;
-    data_size += len;
-}
-
-void NetworkPacket::read (void *ptr, size_t len) {
-    // check buffer underflow
-    check_read_size(len);
-
-    // set value
-    memcpy(ptr, buf + offset, len);
-
-    // update offset
-    offset += len;
-}
-
-template <typename T> T NetworkPacket::read_val (void) {
+/*
+ * NetworkPacketInput
+ */
+template <typename T> T NetworkPacketInput::read_val (void) {
     T val;
 
     // read
@@ -55,90 +17,150 @@
     return val;
 }
 
-template <typename T> void NetworkPacket::write_val (const T &val) {
-    // write
-    write(&val, sizeof(T));
-}
-
-uint32_t NetworkPacket::read_uint32 (void) {
+uint32_t NetworkPacketInput::read_uint32 (void) {
     return ntohl(read_val<uint32_t>());
 }
 
-uint16_t NetworkPacket::read_uint16 (void) {
+uint16_t NetworkPacketInput::read_uint16 (void) {
     return ntohs(read_val<uint16_t>());
 }
 
-uint8_t NetworkPacket::read_uint8 (void) {
+uint8_t NetworkPacketInput::read_uint8 (void) {
     return read_val<uint8_t>();
 }
 
-int32_t NetworkPacket::read_int32 (void) {
+int32_t NetworkPacketInput::read_int32 (void) {
     return ntohl(read_val<int32_t>());
 }
 
-int16_t NetworkPacket::read_int16 (void) {
+int16_t NetworkPacketInput::read_int16 (void) {
     return ntohs(read_val<int16_t>());
 }
 
-int8_t NetworkPacket::read_int8 (void) {
+int8_t NetworkPacketInput::read_int8 (void) {
     return read_val<int8_t>();
 }
         
-float NetworkPacket::read_float32 (void) {
+float NetworkPacketInput::read_float32 (void) {
     int32_t ival = read_int32();
 
     return *((float *) &ival);
 }
 
-Vector NetworkPacket::read_vector (void) {
+Vector NetworkPacketInput::read_vector (void) {
     float fx = read_float32();
     float fy = read_float32();
 
     return Vector(fx, fy);
 }
 
-void NetworkPacket::write_uint32 (uint32_t val) {
+/*
+ * NetworkPacketOutput
+ */
+template <typename T> void NetworkPacketOutput::write_val (const T &val) {
+    // write
+    write(&val, sizeof(T));
+}
+
+
+void NetworkPacketOutput::write_uint32 (uint32_t val) {
     write_val<uint32_t>(htonl(val));
 }
 
-void NetworkPacket::write_uint16 (uint16_t val) {
+void NetworkPacketOutput::write_uint16 (uint16_t val) {
     write_val<uint16_t>(htons(val));
 }
 
-void NetworkPacket::write_uint8 (uint8_t val) {
+void NetworkPacketOutput::write_uint8 (uint8_t val) {
     write_val<uint8_t>(val);
 }
 
-void NetworkPacket::write_int32 (int32_t val) {
+void NetworkPacketOutput::write_int32 (int32_t val) {
     write_val<int32_t>(htonl(val));
 }
 
-void NetworkPacket::write_int16 (int16_t val) {
+void NetworkPacketOutput::write_int16 (int16_t val) {
     write_val<int16_t>(htons(val));
 }
 
-void NetworkPacket::write_int8 (int8_t val) {
+void NetworkPacketOutput::write_int8 (int8_t val) {
     write_val<int8_t>(val);
 }
         
-void NetworkPacket::write_float32 (float val) {
+void NetworkPacketOutput::write_float32 (float val) {
     write_int32(*((int32_t *) &val));
 }
 
-void NetworkPacket::write_vector (const Vector &vec) {
+void NetworkPacketOutput::write_vector (const Vector &vec) {
     write_float32(vec.x);
     write_float32(vec.y);
 }
 
-void NetworkPacket::write_packet (const NetworkPacket &pkt) {
-    // check buffer size
-    check_write_size(pkt.get_data_size());
-
-    // copy
-    memcpy(buf + offset, pkt.get_buf(), pkt.get_data_size());
-
-    // update offset/data_size
-    offset += pkt.get_data_size();
-    data_size += pkt.get_data_size();
+void NetworkPacketOutput::write_packet (const NetworkPacketBuffer &pkt) {
+    // just write() it
+    write(pkt.get_buf(), pkt.get_data_size());
 }
 
+/*
+ * NetworkPacketBuffer
+ */
+NetworkPacketBuffer::NetworkPacketBuffer (char *buf_ptr, size_t buf_size, size_t data_size) :
+    buf_ptr(buf_ptr), buf_size(buf_size), data_size(data_size), offset(0) {
+    
+    // nothing
+    if (buf_ptr == NULL)
+        throw NetworkPacketError("buf_ptr may not be NULL");
+}
+
+void NetworkPacketBuffer::check_write_size (size_t item_size) {
+     if (offset + item_size > buf_size)
+        throw NetworkPacketError("not enough space to write");
+
+}
+        
+void NetworkPacketBuffer::check_read_size (size_t item_size) {
+    if (offset + item_size > data_size)
+        throw NetworkPacketError("not enough data to read");
+}
+
+void NetworkPacketBuffer::write (const void *ptr, size_t len) {
+    // check buffer overflow
+    check_write_size(len);
+
+    // set value
+    memcpy(buf_ptr + offset, ptr, len);
+
+    // update offset and size
+    offset += len;
+    data_size += len;
+}
+
+void NetworkPacketBuffer::read (void *ptr, size_t len) {
+    // check buffer underflow
+    check_read_size(len);
+
+    // set value
+    memcpy(ptr, buf_ptr + offset, len);
+
+    // update offset
+    offset += len;
+}
+
+/*
+ * NetworkPacket
+ */
+NetworkPacket::NetworkPacket (void) : 
+    NetworkPacketBuffer(_buf, NETWORK_PACKET_SIZE, 0) 
+{ 
+    
+}
+
+/*
+ * BigNetworkPacket
+ */
+BigNetworkPacket::BigNetworkPacket (size_t size) :
+    NetworkPacketBuffer((char *) malloc(size), size, 0)
+{
+
+}
+