Beispiel #1
0
	size_t Socket::nonblock_recv(std::vector<std::string::value_type> &buf, const std::chrono::milliseconds &timeWait) const
	{
		size_t recv_len = ~0;
	#ifdef WIN32
        WSAPOLLFD event = {
            socket_handle,
            POLLRDNORM,
            0
        };

        if (1 == ::WSAPoll(&event, 1, timeWait.count() ) && event.revents & POLLRDNORM)
        {
			recv_len = ::recv(socket_handle, buf.data(), buf.size(), 0);
		}
	#elif POSIX
        struct ::pollfd event = {
            socket_handle,
            POLLIN,
            0
        };

        if (1 == ::poll(&event, 1, timeWait.count() ) && event.revents & POLLIN)
		{
			recv_len = ::recv(socket_handle, buf.data(), buf.size(), MSG_NOSIGNAL);
		}
	#else
		#error "Undefine platform"
	#endif
		return recv_len;
	}
Beispiel #2
0
	long Socket::nonblock_recv(std::vector<std::string::value_type> &buf, const std::chrono::milliseconds &timeout) const
	{
		long recv_len = ~0;
	#ifdef WIN32
        WSAPOLLFD event = {
			this->socket_handle,
            POLLRDNORM,
            0
        };

		if (1 == ::WSAPoll(&event, 1, static_cast<::INT>(timeout.count() ) ) && event.revents & POLLRDNORM)
        {
			recv_len = ::recv(this->socket_handle, buf.data(), static_cast<int>(buf.size() ), 0);
		}
	#elif POSIX
        struct ::pollfd event = {
			this->socket_handle,
            POLLIN,
            0
        };

		if (1 == ::poll(&event, 1, timeout.count() ) && event.revents & POLLIN)
		{
			recv_len = ::recv(this->socket_handle, buf.data(), buf.size(), 0);
		}
	#else
		#error "Undefine platform"
	#endif
		return recv_len;
	}
Beispiel #3
0
	size_t Socket::nonblock_send(const std::vector<std::string::value_type> &buf, const size_t length, const std::chrono::milliseconds &timeWait) const
	{
		size_t send_len = ~0;
	#ifdef WIN32
        WSAPOLLFD event = {
            socket_handle,
            POLLWRNORM,
            0
        };

        if (1 == ::WSAPoll(&event, 1, timeWait.count() ) && event.revents & POLLWRNORM)
		{
			send_len = ::send(socket_handle, buf.data(), length, 0);
		}
	#elif POSIX
        struct ::pollfd event = {
            socket_handle,
            POLLOUT,
            0
        };

        if (1 == ::poll(&event, 1, timeWait.count() ) && event.revents & POLLOUT)
		{
			send_len = ::send(socket_handle, buf.data(), length, MSG_NOSIGNAL);
		}
	#else
		#error "Undefine platform"
	#endif
		return send_len;
	}
bool
Piped_request_waiter::Wait(std::chrono::milliseconds timeout)
{
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(read_pipe, &rfds);

    timeval tv = {0, 0};
    timeval* tvp = &tv;
    if (timeout.count() > 0) {
        /* Calculate full seconds and remainder in microseconds. */
        std::chrono::seconds full_sec =
                std::chrono::duration_cast<std::chrono::seconds>(timeout);
        tv.tv_sec = full_sec.count();
        timeout -= full_sec;
        tv.tv_usec = std::chrono::microseconds(timeout).count();
    } else if (timeout.count() < 0) {
        tvp = nullptr;
    }

    int rc = select(read_pipe + 1, &rfds, nullptr, nullptr, tvp);

    if (rc == 0) {
        /* Timeout occurred. */
        return false;
    } else if (rc < 0) {
        VSM_SYS_EXCEPTION("Wait pipe wait error");
    }

    Ack();

    return true;
}
Beispiel #5
0
	Socket Socket::nonblock_accept(const std::chrono::milliseconds &timeWait) const
	{
		System::native_socket_type client_socket = ~0;
	#ifdef WIN32
        WSAPOLLFD event = {
            socket_handle,
            POLLRDNORM,
            0
        };

        if (1 == ::WSAPoll(&event, 1, timeWait.count() ) && event.revents & POLLRDNORM)
		{
			client_socket = ::accept(socket_handle, static_cast<sockaddr *>(nullptr), static_cast<int *>(nullptr) );
		}
	#elif POSIX
        struct ::pollfd event = {
            socket_handle,
            POLLIN,
            0
        };

        if (1 == ::poll(&event, 1, timeWait.count() ) && event.revents & POLLIN)
		{
			client_socket = ::accept(socket_handle, static_cast<sockaddr *>(nullptr), static_cast<socklen_t *>(nullptr) );
		}
	#else
		#error "Undefine platform"
	#endif
		return Socket(client_socket);
	}
Beispiel #6
0
int main(int argc, char* argv[])
{
	std::string receivingInterfaceFilter;

	if(argc>1) {
		if(std::string(argv[1])=="-h") {
			std::cout << "Listens on incoming announces for a specific time. Returns a compact format about all received announcements." << std::endl;
			std::cout << "syntax: " << argv[0] << " <interface name>" << std::endl;
			std::cout << "return format: <family type> <uuid> <type> <name> <address> <netmask> <http port> <interface address> <interface netmask>" << std::endl;
			return 0;
		} else {
			receivingInterfaceFilter = argv[1];
		}
	}

	static const std::chrono::milliseconds timeToWait(10000);
	hbm::devscan::Receiver receiver;

	std::cerr << "Collecting announcements for " << timeToWait.count() << "msec" << std::endl;
	// after collecting announcements for a defined time, we set the announcement callback. As a result, the announce callback is being called for all current announcements.
	try {
		receiver.start_for(timeToWait);
	} catch(hbm::exception::exception& e) {
		std::cerr << "Error starting the receiver: " << e.what() << std::endl;
		return 1;
	}

	receiver.setAnnounceCb(std::bind(&announceCb, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, receivingInterfaceFilter));
	return 0;
}
Beispiel #7
0
bool
shouldCloseLedger (
    bool anyTransactions,
    int previousProposers,
    int proposersClosed,
    int proposersValidated,
    std::chrono::milliseconds previousTime,
    std::chrono::milliseconds currentTime, // Time since last ledger's close time
    std::chrono::milliseconds openTime,    // Time waiting to close this ledger
    std::chrono::seconds idleInterval,
    beast::Journal j)
{
    using namespace std::chrono_literals;
    if ((previousTime < -1s) || (previousTime > 10min) ||
        (currentTime > 10min))
    {
        // These are unexpected cases, we just close the ledger
        JLOG (j.warn()) <<
            "shouldCloseLedger Trans=" << (anyTransactions ? "yes" : "no") <<
            " Prop: " << previousProposers << "/" << proposersClosed <<
            " Secs: " << currentTime.count() << " (last: " <<
            previousTime.count() << ")";
        return true;
    }

    if ((proposersClosed + proposersValidated) > (previousProposers / 2))
    {
        // If more than half of the network has closed, we close
        JLOG (j.trace()) << "Others have closed";
        return true;
    }

    if (!anyTransactions)
    {
        // Only close at the end of the idle interval
        return currentTime >= idleInterval; // normal idle
    }

    // Preserve minimum ledger open time
    if (openTime < LEDGER_MIN_CLOSE)
    {
        JLOG (j.debug()) <<
            "Must wait minimum time before closing";
        return false;
    }

    // Don't let this ledger close more than twice as fast as the previous
    // ledger reached consensus so that slower validators can slow down
    // the network
    if (openTime < (previousTime / 2))
    {
        JLOG (j.debug()) <<
            "Ledger has not been open long enough";
        return false;
    }

    // Close the ledger
    return true;
}
Beispiel #8
0
void Connection::setReceiveTimeout(std::chrono::milliseconds timeout) {
  timeval tv;
  tv.tv_sec = timeout.count() / 1000;
  tv.tv_usec = (timeout.count() % 1000) * 1000;

  if (-1 == setsockopt(socket_, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))) {
    close();
    throw std::runtime_error("Setting receive timeout on socket failed.");
  }
}
void ProxyDestinationMap::setResetTimer(std::chrono::milliseconds interval) {
  assert(interval.count() > 0);
  inactivityTimeout_ = static_cast<uint32_t>(interval.count());
  resetTimer_ =
      folly::AsyncTimeout::make(proxy_->eventBase(), [this]() noexcept {
        resetAllInactive();
        scheduleTimer(false /* initialAttempt */);
      });
  scheduleTimer(true /* initialAttempt */);
}
Beispiel #10
0
void foo() {
   std::chrono::milliseconds const timeout(400);
    
   for (int i = 1; i <= 10; ++i) {      
      std::this_thread::sleep_for(timeout);
       
      std::lock_guard<std::mutex> const guard(mutex);
   	  std::cout << i << timeout.count() << " ms" << std::endl;
   }   
}
Beispiel #11
0
bool socket::wait_for(const std::chrono::milliseconds& timeout) const
{
    auto fds = net::fd_set{};
    FD_ZERO(&fds);
    FD_SET(m_fd, &fds);
    net::timeval tv{
        static_cast<decltype(tv.tv_sec)>(timeout.count() / 1000),
        static_cast<decltype(tv.tv_usec)>(timeout.count() % 1000 * 1000)
    };
    const auto result = net::select(m_fd+1, &fds, nullptr, nullptr, &tv);
    return result > 0;
}
Beispiel #12
0
ConsensusState
checkConsensus (
    int previousProposers,
    int currentProposers,
    int currentAgree,
    int currentFinished,
    std::chrono::milliseconds previousAgreeTime,
    std::chrono::milliseconds currentAgreeTime,
    bool proposing,
    beast::Journal j)
{
    JLOG (j.trace()) <<
        "checkConsensus: prop=" << currentProposers <<
        "/" << previousProposers <<
        " agree=" << currentAgree << " validated=" << currentFinished <<
        " time=" << currentAgreeTime.count() <<  "/" << previousAgreeTime.count();

    if (currentAgreeTime <= LEDGER_MIN_CONSENSUS)
        return ConsensusState::No;

    if (currentProposers < (previousProposers * 3 / 4))
    {
        // Less than 3/4 of the last ledger's proposers are present; don't
        // rush: we may need more time.
        if (currentAgreeTime < (previousAgreeTime + LEDGER_MIN_CONSENSUS))
        {
            JLOG (j.trace()) <<
                "too fast, not enough proposers";
            return ConsensusState::No;
        }
    }

    // Have we, together with the nodes on our UNL list, reached the threshold
    // to declare consensus?
    if (checkConsensusReached (currentAgree, currentProposers, proposing))
    {
        JLOG (j.debug()) << "normal consensus";
        return ConsensusState::Yes;
    }

    // Have sufficient nodes on our UNL list moved on and reached the threshold
    // to declare consensus?
    if (checkConsensusReached (currentFinished, currentProposers, false))
    {
        JLOG (j.warn()) <<
            "We see no consensus, but 80% of nodes have moved on";
        return ConsensusState::MovedOn;
    }

    // no consensus yet
    JLOG (j.trace()) << "no consensus";
    return ConsensusState::No;
}
Beispiel #13
0
void PIDController::setSampleTime(const std::chrono::milliseconds newSampleTime)
{
    if (newSampleTime.count() <= 0) {
        return;
    }

    auto ratio = (float)newSampleTime.count() / mSampleTime.count();

    mKi *= ratio;
    mKd /= ratio;
    mSampleTime = newSampleTime;
}
Beispiel #14
0
std::string StringUtils::formatFPS(std::chrono::milliseconds delta, unsigned int precision)
{
	std::string formatStr;
	long long deltaValue = delta.count();
	if (deltaValue != 0.0)
		formatStr.append(std::to_string(1000.0 / delta.count()));
	else
		formatStr.append("0.0");
	if (formatStr.size() > precision)
		formatStr = formatStr.substr(0, precision);
	return formatStr;
}
Beispiel #15
0
void
ConnectionManager::initiateGracefulShutdown(
  std::chrono::milliseconds idleGrace) {
  if (idleGrace.count() > 0) {
    idleLoopCallback_.scheduleTimeout(idleGrace);
    VLOG(3) << "Scheduling idle grace period of " << idleGrace.count() << "ms";
  } else {
    action_ = ShutdownAction::DRAIN2;
    VLOG(3) << "proceeding directly to closing idle connections";
  }
  drainAllConnections();
}
Beispiel #16
0
void Player::updateY(const std::chrono::milliseconds elapsed_time,
                     const Map& map,
                     ParticleTools& particle_tools)
{
    // Update velocity
    const units::Acceleration gravity = is_jump_active_ && velocity_.y < 0
        ? kJumpGravity
        : kGravity;
    velocity_.y = std::min(velocity_.y + gravity * elapsed_time.count(),
                kMaxSpeedY);
    // Calculate delta
    const units::Game delta = velocity_.y * elapsed_time.count();
    if (delta > 0.0) {
        // Check collision in the direction of delta
        CollisionInfo info = getWallCollisionInfo(map, bottomCollision(delta));
        // React to collision
        if (info.collided) {
            pos_.y = units::tileToGame(info.row) - kCollisionYBottom;
            velocity_.y = 0.0;
            is_on_ground_ = true;
        } else {
            pos_.y += delta;
            is_on_ground_ = false;
        }
        // Check collision in the direction opposite to delta
        info = getWallCollisionInfo(map, topCollision(0));
        if (info.collided) {
            pos_.y = units::tileToGame(info.row) + kCollisionYHeight;
            createHeadBumpParticle(particle_tools);
        }
    } else {
        // Check collision in the direction of delta
        CollisionInfo info = getWallCollisionInfo(map, topCollision(delta));
        // React to collision
        if (info.collided) {
            pos_.y = units::tileToGame(info.row) + kCollisionYHeight;
            createHeadBumpParticle(particle_tools);
            velocity_.y = 0.0;
        } else {
            pos_.y += delta;
            is_on_ground_ = false;
        }
        // Check collision in the direction opposite to delta
        info = getWallCollisionInfo(map, bottomCollision(0));
        if (info.collided) {
            pos_.y = units::tileToGame(info.row) - kCollisionYBottom;
            is_on_ground_ = true;
        }
    }
}
Beispiel #17
0
	long SocketAdapterTls::nonblock_send_all(const void *buf, const size_t length, const std::chrono::milliseconds &timeout) const
	{
		size_t record_size = ::gnutls_record_get_max_size(this->session);

		if (0 == record_size)
		{
			return -1;
		}

		size_t total = 0;

		while (total < length)
		{
			::gnutls_record_set_timeout(this->session, static_cast<unsigned int>(timeout.count() ) );

			if (record_size > length - total)
			{
				record_size = length - total;
			}

			const long send_size = ::gnutls_record_send(this->session, reinterpret_cast<const uint8_t *>(buf) + total, record_size);

			if (send_size < 0)
			{
				return send_size;
			}

			total += send_size;
		}

		return static_cast<long>(total);
	}
Beispiel #18
0
bool cGhast::Attack(std::chrono::milliseconds a_Dt)
{
	m_AttackInterval += (static_cast<float>(a_Dt.count()) / 1000) * m_AttackRate;
	
	if ((m_Target != nullptr) && (m_AttackInterval > 3.0))
	{
		// Setting this higher gives us more wiggle room for attackrate
		Vector3d Speed = GetLookVector() * 20;
		Speed.y = Speed.y + 1;
		cGhastFireballEntity * GhastBall = new cGhastFireballEntity(this, GetPosX(), GetPosY() + 1, GetPosZ(), Speed);
		if (GhastBall == nullptr)
		{
			return false;
		}
		if (!GhastBall->Initialize(*m_World))
		{
			delete GhastBall;
			GhastBall = nullptr;
			return false;
		}
		m_World->BroadcastSpawnEntity(*GhastBall);
		m_AttackInterval = 0.0;
		
		return true;
	}
	return false;
}
Beispiel #19
0
void write_concern::majority(std::chrono::milliseconds timeout) {
    const auto count = timeout.count();
    if ((count < 0) || (count >= std::numeric_limits<std::int32_t>::max()))
        throw logic_error{error_code::k_invalid_parameter};
    libmongoc::write_concern_set_wmajority(_impl->write_concern_t,
                                           static_cast<std::int32_t>(count));
}
Beispiel #20
0
void cLuaState::Push(std::chrono::milliseconds a_Value)
{
	ASSERT(IsValid());

	tolua_pushnumber(m_LuaState, static_cast<lua_Number>(a_Value.count()));
	m_NumCurrentFunctionArgs += 1;
}
Beispiel #21
0
void Timer::sleep(std::chrono::milliseconds duration) {
  assert(dispatcher != nullptr);
  assert(context == nullptr);
  if (stopped) {
    throw InterruptedException();
  }

  Dispatcher::OperationContext timerContext;
  timerContext.context = dispatcher->getCurrentContext();
  timerContext.interrupted = false;
  timer = dispatcher->getTimer();

  struct kevent event;
  EV_SET(&event, timer, EVFILT_TIMER, EV_ADD | EV_ENABLE | EV_ONESHOT, 0, duration.count(), &timerContext);

  if (kevent(dispatcher->getKqueue(), &event, 1, NULL, 0, NULL) == -1) {
    throw std::runtime_error("Timer::stop, kevent() failed, errno=" + std::to_string(errno));
  }

  context = &timerContext;
  dispatcher->dispatch();
  assert(dispatcher != nullptr);
  assert(timerContext.context == dispatcher->getCurrentContext());
  assert(context == &timerContext);
  context = nullptr;
  timerContext.context = nullptr;
  dispatcher->pushTimer(timer);
  if (timerContext.interrupted) {
    throw InterruptedException();
  }
}
Beispiel #22
0
std::unique_ptr<MessageDecoder> Connection::sendSyncMessageFromSecondaryThread(uint64_t syncRequestID, std::unique_ptr<MessageEncoder> encoder, std::chrono::milliseconds timeout)
{
    ASSERT(RunLoop::current() != m_clientRunLoop);

    if (!isValid())
        return nullptr;

    SecondaryThreadPendingSyncReply pendingReply;

    // Push the pending sync reply information on our stack.
    {
        MutexLocker locker(m_syncReplyStateMutex);
        if (!m_shouldWaitForSyncReplies)
            return nullptr;

        ASSERT(!m_secondaryThreadPendingSyncReplyMap.contains(syncRequestID));
        m_secondaryThreadPendingSyncReplyMap.add(syncRequestID, &pendingReply);
    }

    sendMessage(std::move(encoder), 0);

    pendingReply.semaphore.wait(currentTime() + (timeout.count() / 1000.0));

    // Finally, pop the pending sync reply information.
    {
        MutexLocker locker(m_syncReplyStateMutex);
        ASSERT(m_secondaryThreadPendingSyncReplyMap.contains(syncRequestID));
        m_secondaryThreadPendingSyncReplyMap.remove(syncRequestID);
    }

    return std::move(pendingReply.replyDecoder);
}
Beispiel #23
0
void PIT::start_timer(Timer t, std::chrono::milliseconds in_msecs){
  if (in_msecs < 1ms) panic("Can't wait less than 1 ms. ");

  if (current_mode_ != RATE_GEN)
    set_mode(RATE_GEN);

  if (current_freq_divider_ != millisec_interval)
    set_freq_divider(millisec_interval);

  auto cycles_pr_millisec = KHz(CPUFrequency());
  debug("<PIT start_timer> CPU KHz: %f Cycles to wait: %f \n",cycles_pr_millisec.count(), cycles_pr_millisec.count() * in_msecs);

  auto ticks = in_msecs / KHz(current_frequency()).count();
  debug("<PIT start_timer> PIT KHz: %f * %i = %f ms. \n",
	KHz(current_frequency()).count(), (uint32_t)ticks.count(), ((uint32_t)ticks.count() * KHz(current_frequency()).count()));

  t.setStart(OS::cycles_since_boot());
  t.setEnd(t.start() + uint64_t(cycles_pr_millisec.count() * in_msecs.count()));


  auto key = millisec_counter + ticks.count();

  // We could emplace, but the timer exists allready, and might be a reused one
  timers_.insert(std::make_pair(key, t));

  debug("<PIT start_timer> Key: %i id: %i, t.cond()(): %s There are %i timers. \n",
	(uint32_t)key, t.id(), t.cond()() ? "true" : "false", timers_.size());


}
Beispiel #24
0
void Timer::sleep(std::chrono::milliseconds duration) {
  assert(dispatcher != nullptr);
  assert(context == nullptr);
  if (stopped) {
    throw InterruptedException();
  }

  TimerContext context2;
  context2.dispatcher = dispatcher;
  context2.context = dispatcher->getCurrentContext();
  context2.interrupted = false;

  struct kevent event;
  EV_SET(&event, timer, EVFILT_TIMER, EV_ADD | EV_ENABLE | EV_ONESHOT, 0, duration.count(), &context2);

  if (kevent(dispatcher->getKqueue(), &event, 1, NULL, 0, NULL) == -1) {
    std::cerr << "kevent() failed, errno=" << errno << '.' << std::endl;
    throw std::runtime_error("Timer::sleep");
  }

  context = &context2;
  dispatcher->yield();
  assert(dispatcher != nullptr);
  assert(context2.context == dispatcher->getCurrentContext());
  assert(context == &context2);
  context = nullptr;
  context2.context = nullptr;
  if (context2.interrupted) {
    throw InterruptedException();
  }
}
Beispiel #25
0
void cBlaze::Attack(std::chrono::milliseconds a_Dt)
{
	m_AttackInterval += (static_cast<float>(a_Dt.count()) / 1000) * m_AttackRate;

	if ((m_Target != nullptr) && (m_AttackInterval > 3.0))
	{
		// Setting this higher gives us more wiggle room for attackrate
		Vector3d Speed = GetLookVector() * 20;
		Speed.y = Speed.y + 1;
		cFireChargeEntity * FireCharge = new cFireChargeEntity(this, GetPosX(), GetPosY() + 1, GetPosZ(), Speed);
		if (FireCharge == nullptr)
		{
			return;
		}
		if (!FireCharge->Initialize(*m_World))
		{
			delete FireCharge;
			FireCharge = nullptr;
			return;
		}
		m_World->BroadcastSpawnEntity(*FireCharge);
		m_AttackInterval = 0.0;
		// ToDo: Shoot 3 fireballs instead of 1.
	}
}
  void setSyncInterval(uint16_t deviceID,
		       std::chrono::milliseconds syncInterval) {
    sendSDO(deviceID, "ip_time_units",
	    static_cast<uint32_t>( syncInterval.count() ));
    sendSDO(deviceID, "ip_time_index", "milliseconds");
    sendSDO(deviceID, "sync_timeout_factor", 0); // 0 = disable sync timeout
  }
Beispiel #27
0
bool BaseThriftServer::getTaskExpireTimeForRequest(
    std::chrono::milliseconds clientQueueTimeoutMs,
    std::chrono::milliseconds clientTimeoutMs,
    std::chrono::milliseconds& queueTimeout,
    std::chrono::milliseconds& taskTimeout) const {
  taskTimeout = getTaskExpireTime();

  queueTimeout = clientQueueTimeoutMs;
  if (queueTimeout == std::chrono::milliseconds(0)) {
    queueTimeout = getQueueTimeout();
  }

  if (taskTimeout != std::chrono::milliseconds(0) && getUseClientTimeout()) {
    // we add 10% to the client timeout so that the request is much more likely
    // to timeout on the client side than to read the timeout from the server
    // as a TApplicationException (which can be confusing)
    taskTimeout =
        std::chrono::milliseconds((uint32_t)(clientTimeoutMs.count() * 1.1));
  }
  // Queue timeout shouldn't be greater than task timeout
  if (taskTimeout < queueTimeout &&
      taskTimeout != std::chrono::milliseconds(0)) {
    queueTimeout = taskTimeout;
  }
  return queueTimeout != taskTimeout;
}
Beispiel #28
0
bool EventBase::scheduleTimeout(AsyncTimeout* obj,
                                 std::chrono::milliseconds timeout) {
  assert(isInEventBaseThread());
  // Set up the timeval and add the event
  struct timeval tv;
  tv.tv_sec = timeout.count() / 1000LL;
  tv.tv_usec = (timeout.count() % 1000LL) * 1000LL;

  struct event* ev = obj->getEvent();
  if (event_add(ev, &tv) < 0) {
    LOG(ERROR) << "EventBase: failed to schedule timeout: " << strerror(errno);
    return false;
  }

  return true;
}
Beispiel #29
0
zrpc::tBinaryPackage zrpc::CSocket::Handshake(const tBinaryPackage& package,
                         const std::chrono::milliseconds total_timeout/* = std::chrono::milliseconds::max()*/,
                         const std::chrono::milliseconds retry_timeout/* = std::chrono::milliseconds(100)*/)
{
    using namespace std::chrono;

    auto start = system_clock::now();
    if(m_is_sync)
    {
        while(!Send(package))
        {
            if(duration_cast<milliseconds>(system_clock::now() - start) >= total_timeout)
                timeout_error("Failed to send the package on time");
            boost::chrono::milliseconds boost_timeout(retry_timeout.count());
            boost::this_thread::sleep_for(boost_timeout);
        }
    }else
        Send(package);

    auto send_finish = system_clock::now();
    if(duration_cast<milliseconds>(send_finish - start) >= total_timeout)
        timeout_error("Failed to send the package on time");

    tBinaryPackage answer_package;
    auto recv_timeout = total_timeout - duration_cast<milliseconds>(send_finish - start);
    if(!Recv(answer_package, recv_timeout))
        timeout_error("Failed to recv the package on time");

    return answer_package;
}
Beispiel #30
0
void cFireSimulator::SimulateChunk(std::chrono::milliseconds a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk)
{
	cCoordWithIntList & Data = a_Chunk->GetFireSimulatorData();

	int NumMSecs = static_cast<int>(a_Dt.count());
	for (cCoordWithIntList::iterator itr = Data.begin(); itr != Data.end();)
	{
		int x = itr->x;
		int y = itr->y;
		int z = itr->z;
		BLOCKTYPE BlockType = a_Chunk->GetBlock(x, y, z);

		if (!IsAllowedBlock(BlockType))
		{
			// The block is no longer eligible (not a fire block anymore; a player probably placed a block over the fire)
			FLOG("FS: Removing block {%d, %d, %d}",
				itr->x + a_ChunkX * cChunkDef::Width, itr->y, itr->z + a_ChunkZ * cChunkDef::Width
			);
			itr = Data.erase(itr);
			continue;
		}

		// Try to spread the fire:
		TrySpreadFire(a_Chunk, itr->x, itr->y, itr->z);

		itr->Data -= NumMSecs;
		if (itr->Data >= 0)
		{
			// Not yet, wait for it longer
			++itr;
			continue;
		}
		
		// Burn out the fire one step by increasing the meta:
		/*
		FLOG("FS: Fire at {%d, %d, %d} is stepping",
			itr->x + a_ChunkX * cChunkDef::Width, itr->y, itr->z + a_ChunkZ * cChunkDef::Width
		);
		*/
		NIBBLETYPE BlockMeta = a_Chunk->GetMeta(x, y, z);
		if (BlockMeta == 0x0f)
		{
			// The fire burnt out completely
			FLOG("FS: Fire at {%d, %d, %d} burnt out, removing the fire block",
				itr->x + a_ChunkX * cChunkDef::Width, itr->y, itr->z + a_ChunkZ * cChunkDef::Width
			);
			a_Chunk->SetBlock(itr->x, itr->y, itr->z, E_BLOCK_AIR, 0);
			RemoveFuelNeighbors(a_Chunk, itr->x, itr->y, itr->z);
			itr = Data.erase(itr);
			continue;
		}

		if ((itr->y > 0) && (!DoesBurnForever(a_Chunk->GetBlock(itr->x, itr->y - 1, itr->z))))
		{
			a_Chunk->SetMeta(x, y, z, BlockMeta + 1);
		}
		itr->Data = GetBurnStepTime(a_Chunk, itr->x, itr->y, itr->z);  // TODO: Add some randomness into this
	}  // for itr - Data[]
}