IEnumerator PingConnect() { m_PingResServerState = PingState.PingIng; //ResServer IP string ResServerIP = GetCurrentNormalIP(); if (ResServerIP != null) { //Ping網站 Ping ping = new Ping(ResServerIP); int nTime = 0; while (!ping.isDone) { yield return(new WaitForSeconds(0.1f)); if (nTime > 50) // time 2 sec, OverTime { nTime = 0; ShowTips(); m_PingResServerState = PingState.CanNotConnectServer; yield break; } nTime++; } if (ping.isDone) { yield return(ping.time); m_PingResServerState = PingState.PingOK; HideTips(); } } }
private Color GetPingColor(int i_Ping) { PingState pingState = GetPingState(i_Ping); Color pingColor = GetPingColor(pingState); return(pingColor); }
private Sprite GetPingSprite(int i_Ping) { PingState pingState = GetPingState(i_Ping); Sprite pingSprite = GetPingSprite(pingState); return(pingSprite); }
private IEnumerator PingConnect(string ip, NetPingCallBack callback) { if (Config.Detail_Debug_Log()) { Debug.Log("----------net ping 1->" + ip); } state = PingState.PingNotConnect; if (ip == null) { if (callback != null) { callback(false, -1); } yield break; } state = PingState.PingIng; Ping ping = new Ping(ip); int nTime = 0; if (Config.Detail_Debug_Log()) { Debug.Log("----------net ping 2->" + ip); } while (!ping.isDone) { yield return(new WaitForSeconds(0.1f)); if (nTime > 20) //2秒 { nTime = 0; state = PingState.PingNotConnect; if (callback != null) { callback(false, -1); } yield break; } nTime++; } if (Config.Detail_Debug_Log()) { Debug.Log("----------net ping 3->" + ip + "^" + ping.isDone + "^" + ping.time); } if (ping.isDone) { state = PingState.PingOK; if (callback != null) { callback(true, ping.time); } yield break; } }
/// <summary> /// Deserialize the state from a string. /// </summary> /// <param name="Arguments">Supplies the state string that was /// constructed by a call to ToString().</param> /// <returns>A new PingState object containing the deserialized /// contents, else null on failure. An exception may also be /// raised on a failure that is the result of an unexpected /// protocol violation.</returns> public static PingState FromString(string Arguments) { string[] Tokens = Arguments.Split(new char[] { ':' }); if (Tokens == null || Tokens.Length < 2) return null; PingState State = new PingState(Convert.ToUInt32(Tokens[0]), Convert.ToInt32(Tokens[1])); return State; }
/// <summary> /// This method is called to request an IPC channel latency measurement /// to a target server. /// </summary> /// <param name="PCObjectId">Supplies the PC object id of the /// requesting player.</param> /// <param name="ServerId">Supplies the server id to send the ping /// request to.</param> /// <param name="Script">Supplies the script object.</param> public static void SendPingToServer(uint PCObjectId, int ServerId, ACR_ServerCommunicator Script) { // // Package and serialize the ping state for transmission to the // remote server. The remote server will echo the ping back, and // HandleServerPingResponse will then be invoked via a reply // run script request for acr_ping_server_response. // PingState State = new PingState(PCObjectId, Environment.TickCount); Script.RunScriptOnServer(ServerId, "acr_server_ping_request", State.ToString()); }
/// <summary> /// Deserialize the state from a string. /// </summary> /// <param name="Arguments">Supplies the state string that was /// constructed by a call to ToString().</param> /// <returns>A new PingState object containing the deserialized /// contents, else null on failure. An exception may also be /// raised on a failure that is the result of an unexpected /// protocol violation.</returns> public static PingState FromString(string Arguments) { string[] Tokens = Arguments.Split(new char[] { ':' }); if (Tokens == null || Tokens.Length < 2) { return(null); } PingState State = new PingState(Convert.ToUInt32(Tokens[0]), Convert.ToInt32(Tokens[1])); return(State); }
/// <summary> /// This when a cross-server ping response is received. Its purpose is /// to compute the channel latency and send a message to that effect to /// the requesting player. /// </summary> /// <param name="SourceServerId">Supplies the server id of the server /// that completed the ping request.</param> /// <param name="Arguments">Supplies the serialized state arguments /// string.</param> /// <param name="Script">Supplies the current script object.</param> /// <returns>TRUE on success, else FALSE on failure.</returns> public static int HandleServerPingResponse(int SourceServerId, string Arguments, ACR_ServerCommunicator Script) { int Tick = Environment.TickCount; try { PingState RemoteState; // // Deserialize the remote ping state. If null, a protocol // violation has occurred. // if ((RemoteState = PingState.FromString(Arguments)) == null) { Script.WriteTimestampedLogEntry(String.Format( "ACR_ServerCommunicator.ServerLatencyMeasurer.HandleServerPingResponse({0}, {1}): Invalid request.", SourceServerId, Arguments)); return(ACR_ServerCommunicator.FALSE); } string ServerName = Script.GetServerName(SourceServerId); if (ServerName == null) { return(ACR_ServerCommunicator.FALSE); } Script.SendMessageToPC(RemoteState.PCObjectId, String.Format( "IPC channel latency to {0}: {1}ms", ServerName, Tick - RemoteState.TickCount)); } catch (Exception e) { Script.WriteTimestampedLogEntry(String.Format( "ACR_ServerCommunicator.ServerLatencyMeasurer.HandleServerPingResponse({0}, {1}): Exception: {0}", SourceServerId, Arguments, e)); return(ACR_ServerCommunicator.FALSE); } return(ACR_ServerCommunicator.TRUE); }
private void ping_Completed(object sender, MyPing.CompletedEventArgs e) { PingState pingState = (PingState)e.UserState; UpdateRecordsState state = pingState.state; Server server = e.Server; StatisticsRecord record = pingState.record; record.SetResponse(e.RoundtripTime); if (!record.IsEmptyData()) { AppendRecord(server.Identifier(), record); } Logging.Debug($"Ping {server.FriendlyName()} {e.RoundtripTime.Count} times, {(100 - record.PackageLoss * 100)}% packages loss, min {record.MinResponse} ms, max {record.MaxResponse} ms, avg {record.AverageResponse} ms"); if (Interlocked.Decrement(ref state.counter) == 0) { Save(); FilterRawStatistics(); } }
IEnumerator CleanUpObsticlesTiles() { //Debug.Log("NM: Cleaning Up obsticle Tiles"); int CurrentTerrainRemovalCount = 0; Vector2Int TempV2I = new Vector2Int(); for (int ObTiles = 0; ObTiles < TerrainOccupiedNodes.Count; ++ObTiles) { TempV2I = TerrainOccupiedNodes[ObTiles].GridPosition; NodeGrid[TempV2I.X, TempV2I.Y] = null; ++CurrentTerrainRemovalCount; if (CurrentTerrainRemovalCount % RemovalInterval == 0) { yield return(null); } } TerrainOccupiedNodes = null; CurrentPingState = PingState.Complete; //Debug.Log("NM: Cleaning Up obsticle Tiles Compleate!"); }
private Color GetPingColor(PingState i_PingState) { Color pingColor = Color.white; switch (i_PingState) { case PingState.High: pingColor = m_HighPingColor; break; case PingState.Medium: pingColor = m_MediumPingColor; break; case PingState.Low: pingColor = m_LowPingColor; break; } return(pingColor); }
private Sprite GetPingSprite(PingState i_PingState) { Sprite pingSprite = null; switch (i_PingState) { case PingState.High: pingSprite = m_HighPingSprite; break; case PingState.Medium: pingSprite = m_MediumPingSprite; break; case PingState.Low: pingSprite = m_LowPingSprite; break; } return(pingSprite); }
IEnumerator SweepTerrain() { Collider FloorCollider = FindFloor(); //Debug.Log("NM: Sorting Terrain from AI"); int CurrentNodeCount = 0; for (int XIndex = 0; XIndex < GridXLength; ++XIndex) { for (int YIndex = 0; YIndex < GridYLength; ++YIndex) { ++CurrentNodeCount; switch (NodeGrid[XIndex, YIndex].ColliderOverlapCheck(NodeGrid[XIndex, YIndex], FloorCollider)) { case Node.ColliderOwnerType.Null: break; case Node.ColliderOwnerType.AI: ActiveAICB.Add(NodeGrid[XIndex, YIndex].Occupant); AIOccupiedNodes.Add(NodeGrid[XIndex, YIndex]); break; case Node.ColliderOwnerType.Object: TerrainOccupiedNodes.Add(NodeGrid[XIndex, YIndex]); break; } if (CurrentNodeCount % SweepInterval == 0) { yield return(null); } } } CurrentPingState = PingState.Inactive; //Debug.Log("NM: Sorting Terrain from AI Complete!"); }
// void CallCleanUpObsticleTiles() { CurrentPingState = PingState.Culling; StartCoroutine(CleanUpObsticlesTiles()); SetupQuardrents(); }
private async Task RunReaderAsync() { try { if (IsServer) { EnsureBuffer(ClientPreface.Length); await ClientPreface.ReadAsync(inputStream, config.ClientPrefaceTimeout); } var continueRead = true; if (serverUpgradeRequest != null) { var upgrade = serverUpgradeRequest; serverUpgradeRequest = null; var headers = new CompleteHeadersFrameData { StreamId = 1u, Priority = null, Headers = upgrade.Headers, EndOfStream = upgrade.Payload == null, }; var err = await HandleHeaders(headers); if (err != null) { if (err.Value.StreamId == 0) { continueRead = false; } await HandleFrameProcessingError(err.Value); } else if (upgrade.Payload != null) { var buf = config.BufferPool.Rent(upgrade.Payload.Length); Array.Copy( upgrade.Payload, 0, buf, 0, upgrade.Payload.Length); StreamImpl stream = null; lock (shared.Mutex) { shared.streamMap.TryGetValue(1u, out stream); } bool tookBufferOwnership; err = stream.PushBuffer( new ArraySegment <byte>(buf, 0, upgrade.Payload.Length), true, out tookBufferOwnership); if (!tookBufferOwnership) { config.BufferPool.Return(buf); } if (err != null) { if (err.Value.StreamId == 0) { continueRead = false; } await HandleFrameProcessingError(err.Value); } } } while (continueRead) { EnsureBuffer(PersistentBufferSize); var err = await ReadOneFrame(); ReleaseBuffer(PersistentBufferSize); if (err != null) { if (err.Value.StreamId == 0) { continueRead = false; } await HandleFrameProcessingError(err.Value); } } } catch (Exception e) { } await writer.CloseNow(); await writer.Done; Dictionary <uint, StreamImpl> activeStreams = null; lock (shared.Mutex) { activeStreams = shared.streamMap; shared.streamMap = null; shared.Closed = true; } foreach (var kvp in activeStreams) { await kvp.Value.Reset(ErrorCode.ConnectError, fromRemote : true); } PingState pingState = null; lock (shared.Mutex) { if (shared.PingState != null) { pingState = shared.PingState; shared.PingState = null; } } if (pingState != null) { var ex = new ConnectionClosedException(); foreach (var kvp in pingState.PingMap) { kvp.Value.SetException(ex); } } if (!remoteGoAwayTcs.Task.IsCompleted) { remoteGoAwayTcs.TrySetException(new EndOfStreamException()); } if (receiveBuffer != null) { config.BufferPool.Return(receiveBuffer); receiveBuffer = null; } headerReader.Dispose(); }
// void CallTerrainSweep() { CurrentPingState = PingState.Sweeping; StartCoroutine(SweepTerrain()); }
public void AddPing(PingState ping) { _activePings.Add(ping); }