Beispiel #1
0
        public override void ManualReceiveData(BasePacket basePacket)
        {
            switch (basePacket.packetType)
            {
            case PacketType.CamConfig:
                CamConfigPacket ccp = (CamConfigPacket)basePacket;
                switch (ccp.camaraConfigType)
                {
                case CamaraConfigType.ChangeCamara:
                    if (Clients.ContainsKey(TargetBot))
                    {
                        Clients[TargetBot].SendPacket(basePacket);
                    }
                    break;

                case CamaraConfigType.SendFrame:
                    break;

                default:
                    break;
                }
                break;

            case PacketType.CamReceived:
                ReceivedCamFrame = true;
                break;

            case PacketType.CamResolutionReq:
                if (Clients.ContainsKey(TargetBot) == true)
                {
                    Clients[TargetBot].SendPacket(basePacket);
                }
                break;

            case PacketType.CarStatusReceived:
                ReceivedCarStatus = true;
                break;

            case PacketType.CarStatusChangeReq:
                CarStatusChangeReqPacket cscr = (CarStatusChangeReqPacket)basePacket;
                if (Clients.ContainsKey(TargetBot) == true)
                {
                    ((HardwareClient)Clients[TargetBot]).SetCardevice(cscr.ReqCarDevice);
                }
                break;

            case PacketType.CarGPSSpotStatusChangeReq:
                if (Clients.ContainsKey(TargetBot) == true)
                {
                    Clients[TargetBot].SendPacket(basePacket);
                }
                break;

            case PacketType.UpdateDataReq:
                if (Clients.ContainsKey(TargetBot) == true)
                {
                    Clients[TargetBot].SendPacket(basePacket);
                }
                break;

            case PacketType.UpdateConsoleModeReq:
                ConsoleUpdatePacket cup = (ConsoleUpdatePacket)basePacket;
                switch (cup.consoleMode)
                {
                case ConsoleMode.ViewBotList:
                    if (Clients.ContainsKey(TargetBot) == true)
                    {
                        ((HardwareClient)Clients[TargetBot]).RemoveViwer(this);
                        SendPacket(new ConsoleUpdatedPacket(ConsoleMode.ViewBotList));
                        TargetBot = 0;
                    }
                    break;

                case ConsoleMode.ViewSingleBot:
                    if (Clients.ContainsKey(cup.TargetBot))
                    {
                        ReceivedCamFrame  = true;
                        ReceivedCarStatus = true;
                        ((HardwareClient)Clients[cup.TargetBot]).AddViwer(this);
                        TargetBot = cup.TargetBot;
                        SendPacket(new ConsoleUpdatedPacket(ConsoleMode.ViewSingleBot));
                        SendPacket(new DataUpdatedPacket(((HardwareClient)Clients[cup.TargetBot]).modeType));
                        SendPacket(new CarGPSSpotStatusPacket(GPSSpotManagerChangeType.OverWrite, ((HardwareClient)Clients[cup.TargetBot]).spotManager));
                        SendPacket(new CamResolutionPacket(((HardwareClient)Clients[cup.TargetBot]).CamQuality));
                    }
                    else
                    {
                        SendPacket(new ConsoleUpdatedPacket(ConsoleMode.ViewBotList));
                    }
                    break;

                default:
                    break;
                }
                break;

            case PacketType.UniversalCommand:
                break;

            case PacketType.ClientsInfoReq:
                List <ClientInfo> clientInfos = new List <ClientInfo>();
                foreach (var item in Clients)
                {
                    if (item.Value.IsBot == true)
                    {
                        clientInfos.Add(new ClientInfo(item.Value.Id, ((HardwareClient)(item.Value)).gPSPosition));
                    }
                }
                SendPacket(new ClientinfoPacket(clientInfos.ToArray()));
                break;

            default:
                break;
            }
        }
        public string GetPacketMembers(BasePacket basePacket)
        {
            StringBuilder PacketMembers = new StringBuilder("(");

            switch (basePacket.packetType)
            {
            case PacketType.ConnectionStat:
                ConnectionPacket cp = basePacket as ConnectionPacket;
                PacketMembers.Append("IsConnecting: ");
                PacketMembers.Append(cp.IsConnecting);
                PacketMembers.Append(", IsBot: ");
                PacketMembers.Append(cp.IsBot);
                PacketMembers.Append(", HasError: ");
                PacketMembers.Append(cp.HasError);
                break;

            case PacketType.CamFrame:
                CamPacket cap = basePacket as CamPacket;
                PacketMembers.Append("CamFrame: ");
                PacketMembers.Append(cap.CamFrame);
                break;

            case PacketType.CamConfig:
                CamConfigPacket cacc = basePacket as CamConfigPacket;
                PacketMembers.Append("camaraConfigType: ");
                PacketMembers.Append(cacc.camaraConfigType.ToString());
                PacketMembers.Append(", enable: ");
                PacketMembers.Append(cacc.enable);
                break;

            case PacketType.CamResolutionReq:
                CamResolutionReqPacket crqr = basePacket as CamResolutionReqPacket;
                PacketMembers.Append("Resolution: ");
                PacketMembers.Append(crqr.Resolution);
                break;

            case PacketType.CamResolution:
                CamResolutionPacket crr = basePacket as CamResolutionPacket;
                PacketMembers.Append("Resolution: ");
                PacketMembers.Append(crr.Resolution);
                break;

            case PacketType.CamReceived:
                CamPacketRecived cpr = basePacket as CamPacketRecived;
                break;

            case PacketType.CarStatus:
                CarStatusPacket csp = basePacket as CarStatusPacket;
                PacketMembers.Append("cardevice: ");
                PacketMembers.Append(csp.cardevice);
                PacketMembers.Append(", position: ");
                PacketMembers.Append(csp.position);
                PacketMembers.Append(", rotation: ");
                PacketMembers.Append(csp.rotation);
                break;

            case PacketType.CarStatusReceived:
                CarStatusRecivedPacket csrp = basePacket as CarStatusRecivedPacket;
                break;

            case PacketType.CarGPSSpotStatus:
                CarGPSSpotStatusPacket cgpsssp = basePacket as CarGPSSpotStatusPacket;
                PacketMembers.Append("GPSMover: ");
                PacketMembers.Append(cgpsssp.GPSMover);
                PacketMembers.Append(", GPSPosition: ");
                PacketMembers.Append(cgpsssp.GPSPosition);
                PacketMembers.Append(", GPSSpotManagerChangeType: ");
                PacketMembers.Append(cgpsssp.GPSSpotManagerChangeType);
                PacketMembers.Append(", Index: ");
                PacketMembers.Append(cgpsssp.Index);
                break;

            case PacketType.CarStatusChangeReq:
                CarStatusChangeReqPacket cscrp = basePacket as CarStatusChangeReqPacket;
                PacketMembers.Append("ReqCarDevice: ");
                PacketMembers.Append(cscrp.ReqCarDevice);
                break;

            case PacketType.CarGPSSpotStatusChangeReq:
                CarGPSSpotStatusChangeReqPacket cgpssscrp = basePacket as CarGPSSpotStatusChangeReqPacket;
                PacketMembers.Append("GPSMover: ");
                PacketMembers.Append(cgpssscrp.GPSMover);
                PacketMembers.Append(", GPSPosition: ");
                PacketMembers.Append(cgpssscrp.GPSPosition);
                PacketMembers.Append(", GPSSpotManagerChangeType: ");
                PacketMembers.Append(cgpssscrp.GPSSpotManagerChangeType);
                PacketMembers.Append(", Index: ");
                PacketMembers.Append(cgpssscrp.Index);
                break;

            case PacketType.UpdateDataReq:
                DataUpdatePacket dup = basePacket as DataUpdatePacket;
                PacketMembers.Append("modeType: ");
                PacketMembers.Append(dup.modeType);
                break;

            case PacketType.UpdateDataChanged:
                DataUpdatedPacket dudp = basePacket as DataUpdatedPacket;
                PacketMembers.Append("modeType: ");
                PacketMembers.Append(dudp.modeType);
                break;

            case PacketType.UpdateConsoleModeReq:
                ConsoleUpdatePacket cup = basePacket as ConsoleUpdatePacket;
                PacketMembers.Append("consoleMode: ");
                PacketMembers.Append(cup.consoleMode);
                PacketMembers.Append("TargetBot: ");
                PacketMembers.Append(cup.TargetBot);
                break;

            case PacketType.UpdateConsoleModeChanged:
                ConsoleUpdatedPacket cudp = basePacket as ConsoleUpdatedPacket;
                PacketMembers.Append("consoleMode: ");
                PacketMembers.Append(cudp.consoleMode);
                break;

            case PacketType.UniversalCommand:
                UniversalCommandPacket ucp = basePacket as UniversalCommandPacket;
                PacketMembers.Append("key: ");
                PacketMembers.Append(ucp.key);
                PacketMembers.Append("keyType: ");
                PacketMembers.Append(ucp.keyType);
                break;

            case PacketType.ClientsInfoReq:
                ClientinfoReqPacket cirp = basePacket as ClientinfoReqPacket;
                break;

            case PacketType.ClientsInfo:
                ClientinfoPacket cip = basePacket as ClientinfoPacket;
                PacketMembers.Append("ClientsInfo: ");
                PacketMembers.Append(cip.ClientsInfo);
                break;

            default:
                break;
            }
            PacketMembers.Append(')');

            return(PacketMembers.ToString());
        }