C++ (Cpp) Sleepingの例

コード例 #1

ファイル: TWANControler.cpp プロジェクト: AntonLanghoff/whitecatlib

//_________________________________________________________________________________
Boolean TWANControler::UWakeup (Boolean udpMode)
{
	INetAlert alert; SocketStatus err;
	if (!Sleeping()) return true;
	if (TInetControler::UWakeup (false)) {
		err = fServer->ServerOpen (fMaxClients);
		if (err != noErr) {
			alert.FatalError (fDrvName, strWakeUpFailure, strTCPSockOpenFailure, err);
			TInetControler::USleep ();
			return false;
		}
	}
	return true;
}

コード例 #2

ファイル: extension.cpp プロジェクト: Blackvein/MessageBot

// Thread executed
void watchThread::RunThread(IThreadHandle *pHandle)
{
	// Infinite Loop while loaded
	while (extensionLoaded)
	{		
		// steam connection setup
		if (!setup && extensionLoaded)
		{
			setup = DoSetup();
		}

		// Extension loaded?
		if (extensionLoaded)
		{
			// Sleep here, sleeping is sooo good :)
			Sleeping(2000);
		}


		// Item in list?
		if (extensionLoaded && queueStart != NULL)
		{
			// Login
			steamUser->LogOnWithPassword(true, queueStart->getUsername(), queueStart->getPassword());


			// Finished or Error?
			bool finished = false;
			bool foundError = false;

			// Last Callback
			CallbackMsg_t callBack;

			// Timeout
			time_t timeout = time(0) + 10;


			// Not longer as 10 seconds
			while(time(0) < timeout && extensionLoaded)
			{
				// Get last callbacks
				while (GetCallback(pipeSteam, &callBack) && extensionLoaded)
				{
					// Free it
					FreeLastCallback(pipeSteam);


					// Logged In?
					if (callBack.m_iCallback == SteamServersConnected_t::k_iCallback && extensionLoaded)
					{
						Sleeping(rand() % 200 + 1);


						bool foundData = false;
						bool foundUser = false;
						char *message = queueStart->getMessage();


						// Logged in!
						steamUser->SetSelfAsPrimaryChatDestination();
						steamFriends->SetPersonaState(queueStart->getOnline());
						

						// Sleep before sending
						Sleeping(rand() % 400 + 1);
						

						// Add all Recipients and send message
						for (int i = 0; i < MAX_RECIPIENTS; i++)
						{
							// Break if unloaded
							if (!extensionLoaded)
							{
								break;
							}

							// Valid Steamid?
							if (recipients[i] != NULL && steamFriends != NULL)
							{
								// We found one
								foundUser = true;

								// Add Recipients
								if (extensionLoaded && steamFriends->GetFriendRelationship(*recipients[i]) != k_EFriendRelationshipFriend)
								{
									steamFriends->AddFriend(*recipients[i]);
								}


								// Sleep before message
								Sleeping(2);


								// Send him the message
								if (extensionLoaded)
								{
									if (steamFriends->ReplyToFriendMessage(*recipients[i], message))
									{
										// We found one
										foundData = true;
									}
									else if (steamFriends->SendMsgToFriend(*recipients[i], k_EChatEntryTypeChatMsg, message, strlen(message + 1)))
									{
										foundData = true;
									}
								}
							}
						}


						// Array is empty?
						if (!foundUser)
						{
							// Array is Empty !
							prepareForward(queueStart->getCallback(), ARRAY_EMPTY, k_EResultOK);

							// Found Error
							foundError = true;
						}

						// no receiver?
						else if (!foundData)
						{
							prepareForward(queueStart->getCallback(), NO_RECEIVER, k_EResultOK);

							// Found Error
							foundError = true;
						}
						else
						{
							// Success :)
							prepareForward(queueStart->getCallback(), SUCCESS, k_EResultOK);

							finished = true;
						}
					}


					// Error on connect
					else if (callBack.m_iCallback == SteamServerConnectFailure_t::k_iCallback && extensionLoaded)
					{
						// Get Error Code
						SteamServerConnectFailure_t *error = (SteamServerConnectFailure_t *)callBack.m_pubParam;


						// We have a Login Error
						prepareForward(queueStart->getCallback(), LOGIN_ERROR, (EResult)error->m_eResult);


						// Found Error
						foundError = true;
					}


					// We found a error or finished -> stop here
					if (foundError || finished || !extensionLoaded)
					{
						break;
					}
				}


				// We found a error -> stop here
				if (foundError || finished || !extensionLoaded)
				{
					break;
				}


				// Sleep here
				Sleeping(10);
			}


			// Timeout
			if (!foundError && !finished)
			{
				prepareForward(queueStart->getCallback(), TIMEOUT_ERROR, k_EResultOK);
			}


			// Remove last
			queueStart->remove();

			
			// Extension loaded?
			if (extensionLoaded)
			{
				// Sleep here
				Sleeping(200);

				// Logout
				steamUser->LogOff();
			}
		}
	}
}