public void Serialize(JoinAccept message)
 {
     m_writer.Reset();
     m_writer.Write(NetworkMessageType.JoinAccept);
     m_writer.Write(message.m_team);
     m_writer.Flush();
 }
Exemplo n.º 2
0
    public void AcceptClient(INetworkAddress address)
    {
        var joinAccept = new JoinAccept();

        joinAccept.m_team = (byte)(GetClientCount() - 1);
        m_netMsgSerializer.Serialize(joinAccept);
        m_com.Send(m_netMsgSerializer.Data, m_netMsgSerializer.DataSize, address);
    }
    public void Send(byte[] data, int size, INetworkAddress address)
    {
        var netMsg = m_netMsgSerializer.Deserialize(data, size);

        if (netMsg == null)
        {
            return;
        }

        Debug.LogFormat("FakeServerNetworkCommunication: Send, size = {0}, type = {1}", size, netMsg.m_type);

        switch (netMsg.m_type)
        {
        case NetworkMessageType.JoinRequest:
            var msg = new JoinAccept();
            msg.m_team = 0;
            m_netMsgSerializer.Serialize(msg);
            OutMessages.Enqueue(new RawData(m_netMsgSerializer.Data, m_netMsgSerializer.DataSize));
            // TODO: add this message to OutMessages
            break;
        }
    }
    public NetworkMessage Deserialize(byte[] data, int size)
    {
        var message = new NetworkMessage();

        m_reader.Reset(data, size);
        m_reader.Read(out message.m_type);

        switch (message.m_type)
        {
        case NetworkMessageType.JoinRequest:
        {
            var msg = new JoinRequest();
            m_reader.Read(out msg.m_clientVersion);
            m_reader.Read(out msg.m_playerName);
            message.m_msg = msg;
            break;
        }

        case NetworkMessageType.JoinAccept:
        {
            var msg = new JoinAccept();
            m_reader.Read(out msg.m_team);
            message.m_msg = msg;
            break;
        }

        case NetworkMessageType.OpponentFound:
        {
            var msg = new OpponentFound();
            m_reader.Read(out msg.m_playerName);
            message.m_msg = msg;
            break;
        }

        case NetworkMessageType.ReadyToStart:
            break;

        case NetworkMessageType.StartMatch:
            break;

        case NetworkMessageType.PlayerMove:
        {
            var msg = new PlayerMove();
            m_reader.Read(out msg.m_messageNumber);
            m_reader.Read(out msg.m_dt);
            byte direction;
            m_reader.Read(out direction);
            msg.m_playerDirection = (PlayerDirection)direction;
            message.m_msg         = msg;
            break;
        }

        case NetworkMessageType.PlayerPosition:
        {
            var msg = new PlayerPosition();
            m_reader.Read(out msg.m_clientMsgNum);
            m_reader.Read(out msg.m_team);
            m_reader.Read(out msg.m_index);
            m_reader.Read(out msg.m_position);
            byte direction;
            m_reader.Read(out direction);
            msg.m_direction = (PlayerDirection)direction;
            message.m_msg   = msg;
            break;
        }

        case NetworkMessageType.PlayerAction:
        {
            var msg = new Action();
            m_reader.Read(out msg.m_duration);
            message.m_msg = msg;
            break;
        }

        case NetworkMessageType.BallPosition:
        {
            var msg = new BallPosition();
            m_reader.Read(out msg.m_clientMsgNum);
            m_reader.Read(out msg.m_position);
            m_reader.Read(out msg.m_velocity);
            message.m_msg = msg;
            break;
        }

        default:
            Debug.Log("Unknown network message.");
            break;
        }

        return(message);
    }
Exemplo n.º 5
0
        public async Task <byte[]> ProcessJoinRequest(byte[] data)
        {
            byte[] returnvalue;
            try {
                await _dal.BeginTransaction();

                var joinrequest = _lora.UnmarshalJoinRequest(data);
                var device      = await _dal.GetDeviceOnAppEUIDevEUI(ByteArrayToString(joinrequest.AppEUI), ByteArrayToString(joinrequest.DevEUI));

                var appkey = StringToByteArray(device.AppKey);
                var joinrequestvalidated = _lora.UnmarshalJoinRequestAndValidate(appkey, data);
                var devnonce             = ByteArrayToString(joinrequestvalidated.DevNonce);
                if ((await _dal.GetSessionOnDeviceDevNonceActive(device.Id, devnonce)) != null)
                {
                    throw new SessionAllreadyActiveException();
                }
                var nwkid       = GetNwkId();
                var freedevaddr = await _dal.GetFreeDevAddr(nwkid);

                var appnonce = _lora.GetAppNonce();
                var netid    = GetNetId();
                await _dal.SetActiveSessionsInactive(device.Id);

                await _dal.AddSession(new Com.Bekijkhet.MyBroker.Dal.Session()
                {
                    Device   = device.Id,
                    DevAddr  = freedevaddr.Id,
                    DevNonce = devnonce,
                    AppNonce = ByteArrayToString(appnonce),
                    NwkSKey  = ByteArrayToString(_lora.GetNwkSKey(appkey, appnonce, netid, joinrequestvalidated.DevNonce)),
                    AppSKey  = ByteArrayToString(_lora.GetAppSKey(appkey, appnonce, netid, joinrequestvalidated.DevNonce)),
                    Active   = DateTime.UtcNow.AddDays(1)
                });

                var joinaccept = new JoinAccept()
                {
                    Mhdr = new Mhdr()
                    {
                        MType = MType.JoinAccept, Major = 1
                    },
                    AppNonce   = appnonce,
                    NetId      = netid,
                    DevAddr    = Convert.ToUInt32((freedevaddr.NwkId * 16777216) + freedevaddr.NwkAddr),
                    DlSettings = GetDlSettings(),
                    RxDelay    = GetRxDelay(),
                    CfList     = GetCfList()
                };

                returnvalue = _lora.MarshalJoinAccept(joinaccept, appkey);

                _dal.CommitTransaction();
            }
            catch (Exception e) {
                _dal.RollbackTransaction();
                throw;
            }
            finally {
                _dal.Close();
            }
            return(returnvalue);
        }