some errors in BitMessage declaration fixed and some methods implemented in AsyncConnection

src/network/AsyncConnection.cpp

@@ -38,7 +38,7 @@ void AsyncConnection::init(const os::NetAddress addr, const int id)
 	m_remote_sequence = 0;
 	m_local_sequence = 0;
 	m_max_sequence = 0xFFFFFFFF;
-	m_max_rtt = 1;	//in seconds
+	m_max_rtt = 1000;	//in milliseconds
 	m_rtt = 0;		
 	m_last_send_time = 0;
 	m_last_data_bytes = 0;
@@ -104,14 +104,26 @@ float AsyncConnection::get_incoming_packet_loss() const
 void AsyncConnection::send_message(BitMessage& msg, const uint32_t time)
 {
 	m_socket.send(m_remote_address, msg.get_data(), msg.get_size());
-	//TODO
+	_packet_sent(msg.get_size());
 }
 
 //-----------------------------------------------------------------------------
 bool AsyncConnection::receive_message(BitMessage& msg, const uint32_t time)
 {
-	m_socket.receive(m_remote_address, msg.get_data(), msg.get_size());
-	//TODO
+	size_t size;
+	
+	m_socket.receive(m_remote_address, msg.get_data(), size);
+	msg.set_size(size);
+	msg.begin_reading();
+
+	//TODO: check return value of receive
+	BitMessage::Header header;
+
+	msg.read_int32();	// read protocol id
+	header.sequence = msg.read_int32();	// read sequence
+	msg.read_int32();// read ack
+	msg.read_int32();// read ack_bits
+	header.size = msg.read_uint16();// read size
 }
 
 //-----------------------------------------------------------------------------
@@ -195,7 +207,7 @@ void AsyncConnection::_packet_sent(size_t size)
 }
 
 //-----------------------------------------------------------------------------
-void AsyncConnection::_packet_received(uint32_t sequence, size_t size)
+void AsyncConnection::_packet_received(uint16_t sequence, size_t size)
 {
 	BitMessage::Header tmp;
 	BitMessage::Header* h_ptr;
@@ -226,13 +238,54 @@ void AsyncConnection::_packet_received(uint32_t sequence, size_t size)
 }
 
 //-----------------------------------------------------------------------------
-bool AsyncConnection::_sequence_more_recent(uint32_t s1, uint32_t s2)
+void AsyncConnection::_process_ack(uint16_t ack, int32_t ack_bits)
+{
+	if (m_pending_ack.empty())
+	{
+		return;
+	}
+	
+	BitMessage::Header* i = m_pending_ack.begin();
+	while (i != m_pending_ack.end())
+	{
+		bool acked = false;
+		
+		if (i->sequence == ack)
+		{
+			acked = true;
+		}
+		else if (!_sequence_more_recent(i->sequence, ack))
+		{
+			uint32_t bit_index = _bit_index_for_sequence(i->sequence, ack);
+			if (bit_index <= 31)
+			{
+				acked = (ack_bits >> bit_index) & 1;
+			}
+		}
+
+		if (acked)
+		{
+			m_rtt += (i->time - m_rtt) * 0.1f;
+			
+			m_acked.push_back(*i);
+		}
+		else
+		{
+			++i;
+		}
+	}  
+	m_pending_ack.clear();
+}
+
+
+//-----------------------------------------------------------------------------
+bool AsyncConnection::_sequence_more_recent(uint16_t s1, uint16_t s2)
 {
 	return ((s1 > s2) && (s1 - s2 <= m_max_sequence / 2)) || ((s2 > s1) && (s2 - s1<= m_max_sequence / 2 ));
 }
 
 //-----------------------------------------------------------------------------
-uint32_t AsyncConnection::_bit_index_for_sequence(uint32_t seq, uint32_t ack)
+int32_t AsyncConnection::_bit_index_for_sequence(uint16_t seq, uint16_t ack)
 {
 	assert(seq != ack);
 	assert(!_sequence_more_recent(seq, ack));
@@ -252,9 +305,9 @@ uint32_t AsyncConnection::_bit_index_for_sequence(uint32_t seq, uint32_t ack)
 }
 
 //-----------------------------------------------------------------------------
-uint32_t AsyncConnection::_generate_ack_bits(uint32_t ack)
+int32_t AsyncConnection::_generate_ack_bits(uint16_t ack)
 {
-	uint32_t ack_bits = 0;
+	int32_t ack_bits = 0;
 	
 	for (BitMessage::Header* i = m_received_msg.begin(); i != m_received_msg.end(); i++)
 	{
@@ -263,7 +316,7 @@ uint32_t AsyncConnection::_generate_ack_bits(uint32_t ack)
 			break;
 		}
 		
-        uint32_t bit_index = _bit_index_for_sequence(i->sequence, ack);
+        int32_t bit_index = _bit_index_for_sequence(i->sequence, ack);
 		if (bit_index <= 31)
 		{
 			ack_bits |= 1 << bit_index;

src/network/AsyncConnection.h

@@ -50,7 +50,7 @@ public:
 	void							clear_reliable_messages();
 									// Update AsyncConnection
 	void 							update(real delta);
-									// Returns true if the channel is ready to send new data based on the maximum rate.
+									// Returns true if the connection is ready to send new data based on the maximum rate.
 	bool							ready_to_send(const int32_t time) const;
 									// Processes the incoming message.
 	bool							process(const os::NetAddress from, int32_t time, BitMessage &msg, int32_t &sequence);
@@ -59,11 +59,11 @@ private:
 
 									 // methods which provides a reliability system
 	void 							_packet_sent(size_t size);
-	void 							_packet_received(uint32_t sequence, size_t size);
-	void 							_process_ack(uint32_t ack, uint32_t ack_bits);
-	bool							_sequence_more_recent(uint32_t s1, uint32_t s2);
-	uint32_t						_bit_index_for_sequence(uint32_t seq, uint32_t ack);
-	uint32_t						_generate_ack_bits(uint32_t ack);
+	void 							_packet_received(uint16_t sequence, size_t size);
+	void 							_process_ack(uint16_t ack, int32_t ack_bits);
+	bool							_sequence_more_recent(uint16_t s1, uint16_t s2);
+	int32_t							_bit_index_for_sequence(uint16_t seq, uint16_t ack);
+	int32_t							_generate_ack_bits(uint16_t ack);
 	void							_update_outgoing_rate(const uint32_t time, const size_t size);
 	void							_update_incoming_rate(const uint32_t time, const size_t size);
 	void							_update_packet_loss(const uint32_t time, const uint32_t num_recv, const uint32_t num_dropped);

src/network/BitMessage.h

@@ -48,7 +48,7 @@ public:
 						BitMessage(Allocator& allocator);
 						~BitMessage();
 
-	void				init(int32_t len);
+	void				init(int32_t len);								// init with data length in byte
 	uint8_t*			get_data();										// get data for writing
 	const uint8_t*		get_data() const;								// get data for reading
 	size_t				get_max_size() const;							// get the maximum message size
@@ -86,6 +86,8 @@ public:
 	void				write_string(const char* s, int32_t max_len = -1, bool make_7_bit = true);
 	void				write_data(const void* data, int32_t length);
 	void				write_netaddr(const os::NetAddress addr);
+	void				write_header(Header& header);
+
 						// read state utilities
 	void				begin_reading() const;							// begin reading.
 	int32_t				get_remaing_data() const;						// number of bytes left to read
@@ -100,9 +102,7 @@ public:
 	Vec3				read_vec3() const;
 	int32_t				read_string(char* buffer, int32_t buffer_size) const;
 	int32_t				read_data(void* data, int32_t length) const;
-	void				read_netaddr(os::NetAddress* addr) const;	
-						// header utilities
-	void				write_header(Header& header);
+	void				read_netaddr(os::NetAddress* addr) const;
 	size_t				read_header(Header& header);
 
 private:
@@ -114,7 +114,7 @@ private:
 	
 	Allocator*			m_allocator;								// memory allocator
 
-	Header*				m_header;
+	Header*				m_header;									// message header abstraction 
 	
 	uint8_t*			m_data;
 	uint8_t*			m_write;									// pointer to data for writing

tests/messages.cpp

@@ -154,7 +154,7 @@ void test_int32()
 	int32_t res;
 	
 	m.init(4);
-	m.write_int32(4000000);
+	m.write_int32(4000000000);
 	bits_written = m.get_num_bits_written();
 	rem_write_bits = m.get_remaining_write_bits();
 	
@@ -333,11 +333,11 @@ void test_net_address()
 	addr.set(192, 168, 0, 1, 80);
 	
 	m.init(16);
-	m.write_ipv4addr(addr);
+	m.write_netaddr(addr);
 	bits_written = m.get_num_bits_written();
 	rem_write_bits = m.get_remaining_write_bits();	
 	
-	m.read_ipv4addr(&res);
+	m.read_netaddr(&res);
 	bits_read = m.get_num_bits_read();
 	rem_read_bits = m.get_remaining_read_bits();