示例#1
0
        private Byte_Buffer get_buffer(int length)
        {
            Byte_Buffer buffer = new Byte_Buffer();

            buffer.copy(recv_bytes, length);
            return(buffer);
        }
示例#2
0
        static private void recv_callback(IAsyncResult ar)
        {
            Endpoint ep = (Endpoint)ar.AsyncState;

            try
            {
                int ret = ep.socket_.EndReceive(ar);
                if (ret > 0)
                {
                    ep.player_.player_log("从服务器接收" + ret + "字节数据");
                    Byte_Buffer buffer = ep.get_buffer(ret);
                    Game_Manager.instance.process_buffer(ep, buffer);
                    ep.recv();
                }
            }
            catch (Exception ex)
            {
                ep.disconnect();
                if (ep.player_.robot_status != 0)
                {
                    Game_Manager.instance.rmv_player(ep.player_);
                }
                //Log.debug_log(ex.Message);
            }
        }
示例#3
0
        public void send_to_server(uint cmd_id, Bit_Buffer buffer)
        {
            Byte_Buffer buf = new Byte_Buffer();

            buf.make_tcp_begin();
            buf.write_uint8(cmd_id);
            buf.copy(buffer);
            buf.make_tcp_end();
            send(buf);
        }
示例#4
0
 public void copy(Byte_Buffer buffer)
 {
     copy(buffer.rdata(), buffer.readable_length());
 }
示例#5
0
 public int send(Byte_Buffer buffer)
 {
     send(buffer.rdata(), buffer.readable_length());
     return(0);
 }
示例#6
0
        public void process_buffer(Endpoint ep, Byte_Buffer buffer)
        {
            Player p = get_player(ep);

            while (buffer.readable_length() > 0)
            {
                if (p.end_point.merge_state == 0)
                {
                    uint read_len = 0;
                    if (p.end_point.len_data == null)
                    {
                        if (buffer.readable_length() < 2)
                        {
                            p.end_point.len_data    = new byte[2];
                            p.end_point.len_data[0] = (byte)buffer.read_int8();
                            p.end_point.merge_state = 1;
                            return;
                        }
                        read_len = buffer.read_uint16();
                    }
                    else
                    {
                        read_len = BitConverter.ToUInt16(p.end_point.len_data, 0);
                    }
                    uint len = (((read_len) & 0x1f) << 8) | (((read_len) & 0xff00) >> 8);
                    if (p.end_point.buffer_data == null)
                    {
                        if (buffer.readable_length() < (int)len)
                        {
                            p.end_point.buffer_data = new Byte_Buffer();
                            p.end_point.buffer_data.copy(buffer);
                            p.end_point.remain = (int)len - buffer.readable_length();
                            buffer.read_complete();
                            p.end_point.merge_state = 2;
                            return;
                        }
                        uint       cmd = buffer.read_uint8();
                        Bit_Buffer buf = new Bit_Buffer(buffer.rdata(), (int)len - 1);
                        buffer.rpos += ((int)len - 1);
                        process_packet(p, cmd, buf);
                    }
                    else
                    {
                        uint       cmd = p.end_point.buffer_data.read_uint8();
                        Bit_Buffer buf = new Bit_Buffer(p.end_point.buffer_data.rdata(), (int)len - 1);
                        process_packet(p, cmd, buf);
                        p.end_point.buffer_data = null;
                    }
                }
                else
                {
                    if (p.end_point.merge_state == 1)
                    {
                        p.end_point.len_data[1] = (byte)buffer.read_int8();
                        p.end_point.merge_state = 0;
                    }
                    else if (p.end_point.merge_state == 2)
                    {
                        if (buffer.readable_length() < p.end_point.remain)
                        {
                            p.end_point.buffer_data.copy(buffer);
                            p.end_point.remain -= buffer.readable_length();
                            buffer.read_complete();
                            return;
                        }
                        else
                        {
                            p.end_point.buffer_data.copy(buffer.rdata(), p.end_point.remain);
                            buffer.rpos            += p.end_point.remain;
                            p.end_point.merge_state = 0;
                        }
                    }
                }
            }
        }