private void AppendHeaders(NetRequest netRequest, HttpRequestMessage request)
        {
            var headers = netRequest.Parameters.Where(m => m.ParamsOptions == ParameterOptions.HttpHeader || m.ParamsOptions == ParameterOptions.HttpContentHeader);

            if (headers == null || !headers.Any())
            {
                return;
            }

            foreach (var item in headers)
            {
                switch (item.ParamsOptions)
                {
                case ParameterOptions.HttpHeader:
                    switch (item.Name)
                    {
                    case HttpR.AcceptKey:
                        request.Headers.Accept.TryParseAdd(item.Value);
                        break;

                    case HttpR.AcceptEncodingKey:
                        request.Headers.AcceptEncoding.TryParseAdd(item.Value);
                        break;

                    case HttpR.AcceptLanguageKey:
                        request.Headers.AcceptLanguage.TryParseAdd(item.Value);
                        break;

                    case HttpR.UserAgentKey:
                        request.Headers.UserAgent.TryParseAdd(item.Value);
                        break;

                    case HttpR.RefererKey:
                        request.Headers.Referrer = new Uri(item.Value);
                        break;

                    default:
                        request.Headers.TryAddWithoutValidation(item.Name, item.Value);
                        break;
                    }
                    break;

                case ParameterOptions.HttpContentHeader:
                    request.Content.Headers.TryAddWithoutValidation(item.Name, item.Value);
                    break;

                default:
                    break;
                }
            }
        }
Example #2
0
    private void GetStringRequest(string stringKey, NetRequest <NetStream> request, NetConnection connection)
    {
        if (!connection.IsPeer && !connection.IsServer)
        {
            return;
        }
        NetStream stream;

        if (TryGet(stringKey, out stream))
        {
            stream.Position = stream.Size;
            request.Result  = stream;
        }
    }
        private NetRequest CreateRequest(string baseUrl, string referer, HttpMethodOptions methodOptions)
        {
            var request = new NetRequest(baseUrl, methodOptions);

            request.AddParameter(HttpR.CookieKey, _execute12306cnInfo.Cookie, ParameterOptions.HttpHeader);
            request.AddParameter(HttpR.RefererKey, referer, ParameterOptions.HttpHeader);
            request.AddParameter(HttpR.UserAgentKey, HttpR.UserAgent, ParameterOptions.HttpHeader);
            request.AddParameter(HttpR.AcceptKey, HttpR.Accept, ParameterOptions.HttpHeader);
            request.AddParameter(HttpR.AcceptEncodingKey, HttpR.AcceptEncoding, ParameterOptions.HttpHeader);
            request.AddParameter(HttpR.AcceptLanguageKey, HttpR.AcceptLanguage, ParameterOptions.HttpHeader);
            request.AddParameter(HttpR.XRequestedWithKey, HttpR.XRequestedWith, ParameterOptions.HttpHeader);

            return(request);
        }
Example #4
0
        /// <summary>
        /// Translate the text from one language to another.
        /// </summary>
        /// <param name="text">The text to translate.</param>
        /// <param name="to">The language code to translate the text into.</param>
        /// <param name="from">The language code of the translation text.</param>
        /// <param name="appid">If the Authorization is used, leave the appid field empty else specify a string containing "Bearer" + " " + access token.</param>
        /// <param name="authorization">Authorization token: "Bearer" + " " + access token. Required if the appid field is not specified.</param>
        /// <param name="contentType">The format of the text being translated. The supported formats are "text/plain" and "text/html". Any HTML needs to be well-formed.</param>
        /// <param name="category">A string containing the category (domain) of the translation. Defaults to "general".</param>
        /// <returns>The transalted text.</returns>
        public byte[] Translate(string text, string to, string from = null,
                                string appid    = null, string authorization = null, string contentType = null,
                                string category = null)
        {
            string     queryString = "";
            NetRequest request     = new NetRequest();

            // If the authorization has been set and appid is null.
            if (String.IsNullOrEmpty(authorization) && String.IsNullOrEmpty(appid))
            {
                // Error throw
                throw new ArgumentNullException(nameof(appid) + " " + nameof(authorization), "The 'appid' or the 'authorization' must be set.");
            }

            // If the authorization has been set and appid is null.
            if (!String.IsNullOrEmpty(authorization) && String.IsNullOrEmpty(appid))
            {
                // Add the header.
                request.AddHeader("Authorization", authorization);
            }
            else
            {
                queryString += "&appid=" + System.Uri.EscapeDataString(appid);
            }

            // Set the query.
            if ((text != null))
            {
                queryString += "&text=" + System.Uri.EscapeDataString(text);
            }
            if ((to != null))
            {
                queryString += "&to=" + System.Uri.EscapeDataString(to);
            }
            if ((from != null))
            {
                queryString += "&from=" + System.Uri.EscapeDataString(from);
            }
            if ((contentType != null))
            {
                queryString += "&contentType=" + System.Uri.EscapeDataString(contentType);
            }
            if ((category != null))
            {
                queryString += "&category=" + System.Uri.EscapeDataString(category);
            }

            // Make the request.
            return(ProcessRequest("/" + "Translate", queryString, request));
        }
Example #5
0
        public void post(NetRequest oRequest)
        {
            string polystr = "POLYGON ((";

            for (int i = 0; i < oRequest.Geometry.Length; i++)
            {
                polystr += oRequest.Geometry[i][0] + " " + oRequest.Geometry[i][1] + ",";
            }
            polystr  = polystr.TrimEnd(',');
            polystr += "))";
            var service = new NetInfoService();
            var result  = service.GetLists(polystr);

            base.JsonResponse <List <NetInfo> >((List <NetInfo>)result);
        }
Example #6
0
        private async void SendUnitOrderMove(int x, int y)
        {
            UnitOrderMove order = new UnitOrderMove(battleData.id, selectedUnit.unitInstanceId, x, y);

            var request  = NetRequest.CreateAndSend(BBClient.Instance.connection, order);
            var response = await request.WaitForResponse();

            if (response.error == null)
            {
                if (response.GetDataOrDefault <bool>())
                {
                    selectedUnit.ShowOrderArrow(x, y);
                }
            }
        }
Example #7
0
        private async void SendUnitOrderStop(BattleUnit battleUnit)
        {
            UnitOrderStop order = new UnitOrderStop(battleData.id, battleUnit.unitInstanceId);

            var request  = NetRequest.CreateAndSend(BBClient.Instance.connection, order);
            var response = await request.WaitForResponse();

            if (response.error == null)
            {
                if (response.GetDataOrDefault <bool>())
                {
                    selectedUnit.HideOrderArrow();
                }
            }
        }
Example #8
0
        private static void netRequest(string key)
        {
            if (NetRequest.isConnected(Contexts))
            {
                bool success = NetRequest.request(new NetRequesta(key));

                if (!success)
                {
                    toast("激活失败");
                }
            }
            else
            {
                toast("没有连接网络");
            }
        }
Example #9
0
        public async void Start()
        {
            battlePhase = BattlePhase.Starting;

            // Register data handlers
            unitOrderMoveDataHandler = DataHandler.New(HandleUnitOrderMove, new NetDataFilterUnitOrder(battleData.id).And(new NetDataFilterType(typeof(UnitOrderMove))));
            unitOrderStopDataHandler = DataHandler.New(HandleUnitOrderStop, new NetDataFilterUnitOrder(battleData.id).And(new NetDataFilterType(typeof(UnitOrderStop))));
            NetDataEventManager.Instance.RegisterHandler(unitOrderMoveDataHandler);
            NetDataEventManager.Instance.RegisterHandler(unitOrderStopDataHandler);


            // Load players
            LoadBattleRequestData loadBattleRequestData = new LoadBattleRequestData()
            {
                battle = battleData
            };

            NetRequest request1 = NetRequest.CreateAndSend(player1.NetworkingClient.Connection, loadBattleRequestData, Channel.ReliableFragmented);
            NetRequest request2 = NetRequest.CreateAndSend(player2.NetworkingClient.Connection, loadBattleRequestData, Channel.ReliableFragmented);

            await Task.WhenAll(request1.WaitForResponse(), request2.WaitForResponse());

            bool player01Loaded = request1.response.GetDataOrDefault <bool>();
            bool player02Loaded = request2.response.GetDataOrDefault <bool>();

            if (player01Loaded == false || player02Loaded == false)
            {
                Log.Error(LogTag, $"Failed to start BattleSession for BattleData: {battleData}.");
                return;
            }

            // Start battle phases loop
            while (battlePhase != BattlePhase.BattleEnded)
            {
                StartPlanningPhase();
                await WaitForEndOfPhase();

                StartActionPhase();
                await WaitForEndOfPhase();

                if (battleData.unitsOnBoard.Count == 0)
                {
                    battlePhase = BattlePhase.BattleEnded;
                }
            }
        }
Example #10
0
    public static void ResponseGetAccount(NetRequest _request)
    {
        AccountRequest request = (AccountRequest)_request;

        if (request.error != 0)
        {
            //TextManager.instance.ShowErrorCodeMsg(request.cmdId, request.error);
            return;
        }

        AccountInfo.instance.Uid   = request.uid;
        AccountInfo.instance.Token = request.token;

        Debug.LogError("AccountInfo.instance.Uid " + AccountInfo.instance.Uid);
        Debug.LogError("AccountInfo.instance.Token " + AccountInfo.instance.Token);

        RequestGetRoleInfo();
    }
Example #11
0
    /// <summary>
    /// Обновляем данные
    /// </summary>
    public IEnumerator SendUpdateInfo(int points)
    {
        var request = new NetRequest(PacketTypes.updateinfo);

        request.AddParam("points", points);

        return(SendRequest(request).ContinueWith(response =>
        {
            if (response.IsError)
            {
                //Logger.Log("SendUpdateInfoError:", response.GetError);
            }
            else
            {
                //OK
            }
        }));
    }
        private void Ranking_Show()
        {
            State = SelectState.RankingDisplay;

            if (spriteManagerDifficultySelect != null)
            {
                spriteManagerDifficultySelect.FadeOut(200);
            }

            if (rankingSpriteManager != null)
            {
                rankingSpriteManager.Clear();
                rankingSpriteManager.FadeIn(0);
                rankingSpriteManager.ScrollTo(0);
            }
            else
            {
                rankingSpriteManager = new SpriteManagerDraggable {
                    StartBufferZone = BeatmapPanel.PANEL_HEIGHT + 5
                };
            }

            footerHide();

            GameBase.ShowLoadingOverlay = true;

            if (s_SongInfo != null)
            {
                s_SongInfo.FadeOut(100);
            }

            int period = 0;

            rankingNetRequest = new StringNetRequest(@"https://osustream.com/score/retrieve.php", "POST",
                                                     "udid=" + GameBase.Instance.DeviceIdentifier +
                                                     "&filename=" + NetRequest.UrlEncode(Path.GetFileName(Player.Beatmap.ContainerFilename)) +
                                                     "&period=" + period +
                                                     "&difficulty=" + (int)Player.Difficulty);

            rankingNetRequest.onFinish += rankingReceived;

            NetManager.AddRequest(rankingNetRequest);
        }
Example #13
0
        public async Task <HeartBeatResponse> Request(HeartBeat request)
        {
            try
            {
                var model = new NetRequest
                {
                    Data = Newtonsoft.Json.JsonConvert.SerializeObject(request)
                };
                var rs = await GetClient().HeartBeatAsync(model);

                return(Newtonsoft.Json.JsonConvert.DeserializeObject <HeartBeatResponse>(rs.Data));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                return(new HeartBeatResponse()
                {
                    Success = false
                });
            }
        }
Example #14
0
    public IEnumerator SendRequest(NetRequest request)
    {
        Debug.Log(string.Concat(SERVER_PATH, "?", request.GetParamsString()));
        var www = new WWW(string.Concat(SERVER_PATH, "?", request.GetParamsString()));

        while (!www.isDone)
        {
            yield return(www);
        }

        if (!string.IsNullOrEmpty(www.error))
        {
            //Logger.Log("[Network] SendRequest ERROR:" + www.error);
            yield return(new NetResponse("error=" + www.error));

            yield break;
        }

        //Logger.Log("[Network] input data:{0}", www.text);
        yield return(new NetResponse(www.text));
    }
Example #15
0
        public async Task <RequestVoteResponse> Request(RequestVote request)
        {
            try
            {
                var model = new NetRequest
                {
                    Data = Newtonsoft.Json.JsonConvert.SerializeObject(request)
                };
                var rs = await GetClient().VoteAsync(model);

                return(Newtonsoft.Json.JsonConvert.DeserializeObject <RequestVoteResponse>(rs.Data));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                return(new RequestVoteResponse()
                {
                    VoteGranted = false,
                });
            }
        }
Example #16
0
        /// <summary>
        /// 客户端的请求
        /// </summary>
        public string ClientRequest(string rRoute, JsonNode rMsg, Action <JsonNode, JsonNode> rOnResponse)
        {
            string rRequestGUID = Guid.NewGuid().ToString();
            var    rNetRequest  = new NetRequest()
            {
                GUID            = rRequestGUID,
                Route           = rRoute,
                Message         = rMsg,
                OnResponseEvent = rOnResponse,
                IsReceived      = false
            };

            this.mNetRequestDict.Add(rRequestGUID, rNetRequest);
            this.mClient.request(rRoute, rMsg, (rResultMsg) =>
            {
                Debug.Log("NetworkMsg -- " + rRoute + ": " + rResultMsg);
                rNetRequest.ResultMessage = rResultMsg;
                rNetRequest.IsReceived    = true;
            });
            return(rRequestGUID);
        }
Example #17
0
        public async Task <EndorseResponse> Endorse(EndorseRequest request)
        {
            try
            {
                var model = new NetRequest
                {
                    Data = Newtonsoft.Json.JsonConvert.SerializeObject(request)
                };
                var rs = await GetClient().EndorseAsync(model);

                return(Newtonsoft.Json.JsonConvert.DeserializeObject <EndorseResponse>(rs.Data));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                return(new EndorseResponse()
                {
                    Status = false,
                    Msg = ex.Message
                });
            }
        }
        private void AppendCookies(NetRequest netRequest, HttpRequestMessage request)
        {
            var items = netRequest.Parameters.Where(m => m.ParamsOptions == ParameterOptions.Cookie);

            if (items == null || !items.Any())
            {
                return;
            }

            var sCookie = string.Join(";", items.Select(m => m.ToString()));

            if (request.Headers.TryGetValues(HttpR.CookieKey, out var values))
            {
                var cookieValue = values.First().Trim(';');
                request.Headers.Remove(HttpR.CookieKey);
                request.Headers.Add(HttpR.CookieKey, string.Format("{0}{1}{2}", cookieValue, string.IsNullOrEmpty(cookieValue) ? "" : ";", sCookie));
            }
            else
            {
                request.Headers.Add(HttpR.CookieKey, sCookie);
            }
        }
Example #19
0
        //peer级别

        //[Authorize(Roles = "Peer")]
        public override async Task <NetResponse> AppendEntries(NetRequest request, ServerCallContext context)
        {
            try
            {
                var model = Newtonsoft.Json.JsonConvert.DeserializeObject <AppendEntries>(request.Data);
                var rs    = await _raftNet.Handle(model);

                return(new NetResponse()
                {
                    Data = Newtonsoft.Json.JsonConvert.SerializeObject(rs)
                });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                var rs = new AppendEntriesResponse();
                rs.Success = false;
                return(new NetResponse()
                {
                    Data = Newtonsoft.Json.JsonConvert.SerializeObject(rs)
                });
            }
        }
        private void AppendContent(NetRequest netRequest, HttpRequestMessage request)
        {
            if (netRequest.Method == HttpMethodOptions.Post)
            {
                if (_isDefaultContentType)
                {
                    var formItems = netRequest.Parameters.Where(m => m.ParamsOptions == ParameterOptions.FormUrlEncodedContent);
                    if (formItems != null && formItems.Any())
                    {
                        request.Content = new FormUrlEncodedContent(formItems.ToNvcs());
                    }
                }
            }

            var items = netRequest.Parameters.Where(m => m.ParamsOptions == ParameterOptions.GetOrPost);

            if (items == null || !items.Any())
            {
                return;
            }

            request.Content = new ByteArrayContent(items.ToParameterString().AsBytes());
        }
Example #21
0
    public void SendCommand(NetRequest request, ServerCallbackDelegate callback)
    {
        if (!isOfflinePlay)
        {
            Debug.Log("[SEND MSG]" + request.GetType().Name + "=>");
            _client.SendCommand(request, delegate(NetResponse msg) {
                callback(msg);
                Debug.Log("[RECIVE MSG]" + request.GetType().Name + "<=" + msg.ToString());
            });
            return;
        }

        Regex    regex   = new Regex("Request");
        string   cmdname = regex.Split(request.GetType().Name)[0];
        FileInfo info    = new FileInfo(Application.streamingAssetsPath + "/command/" + cmdname + ".txt");

        if (!info.Exists)
        {
            Debug.Log("[NOT RUN MSG]" + cmdname + "");
            return;
        }

        NetResponse response = Activator.CreateInstance(
            Assembly.GetAssembly(request.GetType())
            .GetType(cmdname + "Response")
            ) as FaustComm.NetResponse;
        FileStream fs = info.OpenRead();

        fs.Position = 0;
        BinaryReader br = new BinaryReader(fs);

        response.Decode(br);
        callback(response);
        fs.Close();
        fs.Dispose();
        Debug.Log("[RUN MSG]" + cmdname + "");
    }
    bool ParseOneResponse(object obj)
    {
        Dictionary <string, object> dic = (Dictionary <string, object>)obj;

        if (dic != null)
        {
            if (dic.ContainsKey("o"))
            {
                int selId = int.Parse(dic["o"].ToString());
                if (requests.ContainsKey((int)selId))
                {
                    NetRequest request = requests[(int)selId];
                    request.Respond(dic);

                    //if (request.resultFlag == 0)
                    //{
                    //	return true;
                    //}
                    if (request.isDone)
                    {
                        lock (NetworkManager.instance.mRequestStack)
                        {
                            NetworkManager.instance.mRequestStack.Remove(request);
                        }
                        return(true);
                    }

                    NetworkManager.instance.mErrorRequestSerialId = request.serialId;
                    NetworkManager.instance.mErrorCommandId       = request.cmdId;
                    NetworkManager.instance.mErrorCode            = request.resultFlag;
                }
            }
        }

        return(false);
    }
Example #23
0
        //peer级别

        //[Authorize(Roles = "Peer")]
        public override async Task <NetResponse> BlockHandOut(NetRequest request, ServerCallContext context)
        {
            try
            {
                var model = Newtonsoft.Json.JsonConvert.DeserializeObject <HandOutRequest>(request.Data);
                var rs    = await _txService.BlockHandOut(model);

                return(new NetResponse()
                {
                    Data = Newtonsoft.Json.JsonConvert.SerializeObject(rs)
                });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                var rs = new HandOutResponse();
                rs.Success = false;
                rs.Message = ex.Message;
                return(new NetResponse()
                {
                    Data = Newtonsoft.Json.JsonConvert.SerializeObject(rs)
                });
            }
        }
    public void GetPlayerInfo(int uid, Action<JsonData> action)
    {
        NetRequest req = new NetRequest (CMD_GET_PLAYER_INFO);
 private void AddRequest(NetStream stream, NetRequest<ulong> request, NetConnection connection) {
     if (!connection.IsPeer && !connection.IsServer) return;
     request.Result = Add(stream);
 }
 private void TryAddRequest(string stringKey, NetStream stream, NetRequest<ulong> request, NetConnection connection) {
     if (!connection.IsPeer && !connection.IsServer) return;
     ulong result;
     if (TryAdd(stringKey, stream, out result)) request.Result = result;
 }
 private void GetKeyRequest(string stringKey, NetRequest<ulong> request, NetConnection connection) {
     if (!connection.IsPeer && !connection.IsServer) return;
     ulong result;
     if (TryGetKey(stringKey, out result)) request.Result = result;
 }
 private void GetStringRequest(string stringKey, NetRequest<NetStream> request, NetConnection connection) {
     if (!connection.IsPeer && !connection.IsServer) return;
     NetStream stream;
     if (TryGet(stringKey, out stream)) {
         stream.Position = stream.Size;
         request.Result = stream;
     }
 }
Example #29
0
 public NetData(NetRequest type, PacketForm form)
 {
     m_data = form;
     m_type = type;
 }
 public async Task RunTest()
 {
     var request  = new NetRequest("https://qq283335746.github.io/Home.html?r=20195001");
     var response = await _client.ExecuteAsync(request);
 }
Example #31
0
        private void serviceThreadRoutine()
        {
            Server previousServer = null;

            while (running)
            {
                //Console.WriteLine("New Server Enter");
                lock (eventHandles)
                {
                    previousServer = server;
                    server         = new Server();
                    if (previousServer != null)
                    {
                        server.requestQueue  = previousServer.requestQueue;
                        server.responseQueue = previousServer.responseQueue;
                        server.eventQueue    = previousServer.eventQueue;
                    }
                    else
                    {
                        server.requestQueue  = new SyncQueue <NetRequest>();
                        server.responseQueue = new SyncQueue <NetRequest>();
                        server.eventQueue    = new SyncQueue <NetEvent> [(int)NetServiceChannel.Count];
                        for (var i = 0; i < server.eventQueue.Length; i++)
                        {
                            server.eventQueue[i] = new SyncQueue <NetEvent>();
                        }
                    }
                }
                //Console.WriteLine("New Server Exit");

                Thread recvThread = null;
                Thread beatThread = null;
                connected = false;
                connectDone.Reset();

                try
                {
                    server.soc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    //server.soc.NoDelay = true;

                    Console.WriteLine("Connecting to Server " + serverIp);

                    server.soc.BeginConnect(serverIp, serverPort, ConnectCallback, server.soc);

                    connectDone.WaitOne(1000, true);
                    if (!connected)
                    {
                        Console.WriteLine("Connect to Server Timeout");
                        throw new Exception("Connect to Server Timeout");
                    }

                    Console.WriteLine("Connected to Server " + server.soc.RemoteEndPoint);

                    recvThread = new Thread(recvThreadRoutine);
                    recvThread.Start(server);

                    beatThread = new Thread(beatThreadRoutine);
                    beatThread.Start();

                    server.eventQueue[(int)NetServiceChannel.Secondary].EnQueue(new NetEvent
                    {
                        Type = "Connect"
                    });

                    while (true)
                    {
#if NET_DEBUG
                        sendThreadStopwatch.Start();
#endif

                        NetRequest request = server.requestQueue.Peek();
                        //Console.WriteLine("Receive Request " + request.Type);
                        if (request.Type == "Exception")
                        {
                            throw new Exception(request.Content["Content"].ToString());
                        }

                        sendBody(server.soc, NetServiceChannel.Primary, request.Content.ToString(), request.Data);

                        server.requestQueue.DeQueue();

                        if (!request.FlowOpt)
                        {
                            var e = server.eventQueue[(int)NetServiceChannel.Primary].DeQueue();
                            if (request.Handler != null)
                            {
                                server.responseQueue.EnQueue(new NetRequest
                                {
                                    Type    = e.Type,
                                    Content = e.Content,
                                    Data    = e.Data,
                                    Param   = request.Param,
                                    Handler = request.Handler
                                });
                            }
                        }

                        pool.ReleaseRequest(request);
#if NET_DEBUG
                        sendThreadStopwatch.Stop();
#endif
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
                finally
                {
                    if (connected)
                    {
                        server.eventQueue[(int)NetServiceChannel.Secondary].EnQueue(new NetEvent
                        {
                            Type = "Disconnect"
                        });
                    }

                    if (beatThread != null)
                    {
                        beatThread.Interrupt();
                    }
                    if (server.soc != null)
                    {
                        server.soc.Close();
                    }
                }

                Console.WriteLine("Disconnected Wait 1s to reconnect...");
                Thread.Sleep(1000);
            }

            Console.WriteLine("Net Thread Exit");
        }
Example #32
0
 public void setFactory()
 {
     m_NetRequest = RhoClassFactory.createNetRequest();
 }
Example #33
0
 /// <summary>
 /// 发数据
 /// </summary>
 /// <param name="message">请求</param>
 public void SendRequest(NetRequest request)
 {
     //将请求放入队列
     requestQueue.Enqueue(request);
 }
Example #34
0
 public static void ResponseGetRoleInfo(NetRequest _request)
 {
     GetRoleInfoRequest request = (GetRoleInfoRequest)_request;
 }
Example #35
0
using UnityEngine;
Example #36
0
        private void doSubmission()
        {
            int deviceType = 0;

#if iOS
            if (!GameBase.Mapper)
            {
                deviceType = (int)osum.Support.iPhone.HardwareDetection.Version;

                //todo: for iOS5 twitter authentication, we need to double-check we actually have auth.
                string hash = GameBase.Config.GetValue <string>("hash", null);
                if (hash == null)
                {
                    //todo: no twitter auth. are we not submitting anymore?
                    return;
                }
                else if (hash.StartsWith("ios-"))
                {
                    hash = hash.Substring(4);
                    using (ACAccountStore store = new ACAccountStore())
                    {
                        ACAccount account = store.FindAccount(hash);
                        if (account != null)
                        {
                            //yay, i think.
                            //todo: test that this actually checks grants (it should in theory).
                        }
                        else
                        {
                            GameBase.Notify("Twitter authentication failed. Please visit the options screen to login again.");
                            GameBase.Config.SetValue <string>("username", null);
                            GameBase.Config.SetValue <string>("hash", null);
                            GameBase.Config.SetValue <string>("twitterId", null);
                            GameBase.Config.SaveConfig();
                            return;
                        }
                    }
                }

                string check = CryptoHelper.GetMd5String("moocow" +
                                                         GameBase.Instance.DeviceIdentifier +
                                                         RankableScore.count100 +
                                                         RankableScore.count300 +
                                                         RankableScore.count50 +
                                                         RankableScore.countMiss +
                                                         RankableScore.maxCombo +
                                                         RankableScore.spinnerBonusScore +
                                                         RankableScore.comboBonusScore +
                                                         RankableScore.accuracyBonusScore +
                                                         RankableScore.Ranking +
                                                         Path.GetFileName(Player.Beatmap.ContainerFilename) +
                                                         deviceType +
                                                         RankableScore.hitScore +
                                                         (int)Player.Difficulty);

                string postString =
                    "udid=" + GameBase.Instance.DeviceIdentifier +
                    "&count300=" + RankableScore.count300 +
                    "&count100=" + RankableScore.count100 +
                    "&count50=" + RankableScore.count50 +
                    "&countMiss=" + RankableScore.countMiss +
                    "&maxCombo=" + RankableScore.maxCombo +
                    "&spinnerBonus=" + RankableScore.spinnerBonusScore +
                    "&comboBonus=" + RankableScore.comboBonusScore +
                    "&accuracyBonus=" + RankableScore.accuracyBonusScore +
                    "&hitScore=" + RankableScore.hitScore +
                    "&rank=" + RankableScore.Ranking +
                    "&filename=" + NetRequest.UrlEncode(Path.GetFileName(Player.Beatmap.ContainerFilename)) +
                    "&cc=" + GameBase.Config.GetValue <string>("hash", string.Empty) +
                    "&c=" + check +
                    "&difficulty=" + (int)Player.Difficulty +
                    "&username="******"username", string.Empty) +
                    "&twitterid=" + GameBase.Config.GetValue <string>("twitterId", string.Empty) +
                    "&dt=" + deviceType +
                    "&offset=" + avg;

                spriteSubmitting = new pSprite(TextureManager.Load(OsuTexture.songselect_audio_preview), FieldTypes.StandardSnapRight, OriginTypes.Centre, ClockTypes.Game, new Vector2(20, 20), 0.999f, true, Color4.White)
                {
                    ExactCoordinates = false,
                    DimImmune        = true,
                    ScaleScalar      = 0.7f
                };

                spriteSubmitting.Transform(new TransformationF(TransformationType.Rotation, 0, MathHelper.Pi * 2, Clock.Time, Clock.Time + 1500)
                {
                    Looping = true
                });
                GameBase.MainSpriteManager.Add(spriteSubmitting);
                spriteSubmitting.FadeInFromZero(300);

                StringNetRequest nr = new StringNetRequest("https://www.osustream.com/score/submit.php", "POST", postString);
                nr.onFinish += delegate(string result, Exception e)
                {
                    spriteSubmitting.AlwaysDraw = false;
                    if (e == null)
                    {
                        spriteSubmitting.FadeOut(200);
                        spriteSubmitting.ScaleTo(3, 200);
                        spriteSubmitting.Colour = Color4.YellowGreen;
                    }
                    else
                    {
                        spriteSubmitting.FadeOut(1000);
                        spriteSubmitting.ScaleTo(1.2f, 200, EasingTypes.In);
                        spriteSubmitting.Colour = Color4.Red;
                    }

                    if (e == null && result != null && result.StartsWith("message:"))
                    {
                        rankingNotification = new Notification("Ranking", result.Replace("message:", string.Empty), NotificationStyle.Okay);
                        if (finishedDisplaying)
                        {
                            GameBase.Notify(rankingNotification);
                        }
                    }
                };
                NetManager.AddRequest(nr);
            }
#endif
        }