inline void spawn(
  spawn_type spw,
  actor<stackless>& sire, match_t func, SpawnHandler h,
  match_t ctxid = ctxid_nil,
  link_type type = no_link,
  std::size_t stack_size = default_stacksize(),
  seconds_t tmo = seconds_t(GCE_DEFAULT_REQUEST_TIMEOUT_SEC)
  )
{
  aid_t aid;
  sid_t sid = sire.spawn(spw, func, ctxid, stack_size);
  boost::uint16_t err = 0;
  sid_t ret_sid = sid_nil;

  duration_t curr_tmo = tmo;
  typedef boost::chrono::system_clock clock_t;
  clock_t::time_point begin_tp = clock_t::now();
  match mach(curr_tmo);
  mach.match_list_.push_back(detail::msg_spawn_ret);
  sire.recv(
    boost::bind(
      &handle_remote_spawn, _1, _2, _3,
      type, begin_tp, sid, tmo, curr_tmo, spawn_handler_t(h)
      ),
    mach
    );
}

  actor_id spawn(actor sire, F&& f, fiber_meta meta)
  {
    // Create actor handler.
    actor_handler_t hdr(f);

    // Generate actor_id.
    auto aid = generate_actor_id();

    // Spawn an coctx.
    asev::strand_t snd(*evs_);
    auto sire_aid = sire == nullactor ? nullaid : sire.get_actor_id();
    if (sire_aid != nullaid && meta.ssire_)
    {
      snd = sire.get_strand();
    }

    snd.spawn(
      [this, sire_aid, hdr, aid](asev::corctx_t& ctx)
      {
        // Alloc fiber_actor.
        auto a = fiber_actor_pool_->get();
        // Run actor.
        a->init(aid, ctx.get_strand());
        a->run(ctx, sire_aid, std::move(hdr));
      },
      coctx::make_stacksize(meta.ssize_)
      );
    return aid;
  }

inline void handle_remote_spawn(
  actor<stackless>& self, aid_t aid,
  message msg, link_type type,
  boost::chrono::system_clock::time_point begin_tp,
  sid_t sid, seconds_t tmo, duration_t curr_tmo,
  spawn_handler_t const& hdr
  )
{
  boost::uint16_t err = 0;
  sid_t ret_sid = sid_nil;
  msg >> err >> ret_sid;

  do
  {
    if (err != 0 || (aid && sid == ret_sid))
    {
      break;
    }

    if (tmo != infin)
    {
      duration_t pass_time = boost::chrono::system_clock::now() - begin_tp;
      curr_tmo -= pass_time;
    }

    begin_tp = boost::chrono::system_clock::now();
    match mach(curr_tmo);
    mach.match_list_.push_back(detail::msg_spawn_ret);
    self.recv(
      boost::bind(
        &handle_remote_spawn, _1, _2, _3,
        type, begin_tp, sid, tmo, curr_tmo, hdr
        ),
      mach
      );
    return;
  }
  while (false);

  detail::spawn_error error = (detail::spawn_error)err;
  if (error != detail::spawn_ok)
  {
    aid = aid_t();
  }

  if (aid)
  {
    if (type == linked)
    {
      self.link(aid);
    }
    else if (type == monitored)
    {
      self.monitor(aid);
    }
  }

  hdr(self, aid);
}

bool manager::actualize_doors_state	( actor& actor, float const average_speed )
{
	float const radius		= average_speed*g_door_open_time + g_door_length;
	Fvector const& position	= actor.get_position();
	//check_bug_door			( );
	m_doors.nearest			( position, radius, m_nearest_doors );
	//check_bug_door			( );
	if ( m_nearest_doors.empty() && !actor.need_update() )
		return				true;

	return					actor.update_doors( m_nearest_doors, average_speed );
}

actor operator*(actor f, actor g) {
  auto& sys = f->home_system();
  return make_actor<decorator::sequencer, actor>(
    sys.next_actor_id(), sys.node(), &sys,
    actor_cast<strong_actor_ptr>(std::move(f)),
    actor_cast<strong_actor_ptr>(std::move(g)), std::set<std::string>{});
}

void send_message(actor& source, actor& target, const std::string& message)
{
    ac_message_t msg;
    msg.src = &source;
    msg.message = message;
    target.enqueue(msg);
}

void renderer::animateActor(actor &character, bool isMoving)
{
	double temp[2];
		(character.animationStep > 6) ? character.animationStep = 0 : 0;
	
	switch(character.face)
	{
		case Up: 
		case UpRight: 
		case UpLeft: 
			temp[1] = .25;
			break;
		case Left: temp[1] = 0;
			break;
		case Down:
		case DownRight:
		case DownLeft: temp[1] = .75;
			break;
		case Right: temp[1] = .5;
			break;
		default:
			break;
	}
	temp[0] = double(character.animationStep)*.125;
	character.animationStep++;
	characterData[character.getID()].moveActorCoords(temp);
}

void actor_registry::put_named(atom_value key, actor value) {
  if (value)
    value->attach_functor([=](uint32_t) {
      detail::singletons::get_actor_registry()->put_named(key, invalid_actor);
    });
  exclusive_guard guard{named_entries_mtx_};
  named_entries_.emplace(key, std::move(value));
}

message_id local_actor::sync_send_tuple_impl(message_priority mp,
                                             const actor& dest,
                                             any_tuple&& what) {
    auto nri = new_request_id();
    if (mp == message_priority::high) nri = nri.with_high_priority();
    dest->enqueue({address(), dest, nri}, std::move(what));
    return nri.response_id();
}

void send_as(const actor& from, message_priority prio,
             const channel& to, Ts&&... xs) {
  if (! to) {
    return;
  }
  message_id mid;
  to->enqueue(from.address(),
              prio == message_priority::high ? mid.with_high_priority() : mid,
              make_message(std::forward<Ts>(xs)...), nullptr);
}

inline void handle_spawn(
  actor<stackless>& self, aid_t aid,
  message msg, link_type type, spawn_handler_t const& hdr
  )
{
  if (aid)
  {
    if (type == linked)
    {
      self.link(aid);
    }
    else if (type == monitored)
    {
      self.monitor(aid);
    }
  }

  hdr(self, aid);
}

 void delegate(message_priority mp, const actor& dest, Ts&&... xs) {
   static_assert(sizeof...(Ts) > 0, "no message to send");
   if (! dest)
     return;
   auto mid = current_element_->mid;
   current_element_->mid = mp == message_priority::high
                            ? mid.with_high_priority()
                            : mid.with_normal_priority();
   current_element_->msg = make_message(std::forward<Ts>(xs)...);
   dest->enqueue(std::move(current_element_), host());
 }

void local_actor::forward_message(const actor& dest, message_priority prio) {
  if (!dest) {
    return;
  }
  auto id = (prio == message_priority::high)
              ? m_current_node->mid.with_high_priority()
              : m_current_node->mid.with_normal_priority();
  dest->enqueue(m_current_node->sender, id, m_current_node->msg, host());
  // treat this message as asynchronous message from now on
  m_current_node->mid = invalid_message_id;
}

message_id local_actor::sync_send_tuple_impl(message_priority mp,
                                             const actor& dest,
                                             any_tuple&& what) {
    if (!dest) {
        throw std::invalid_argument("cannot send synchronous message "
                                    "to invalid_actor");
    }
    auto nri = new_request_id();
    if (mp == message_priority::high) nri = nri.with_high_priority();
    dest->enqueue({address(), dest, nri}, std::move(what), m_host);
    return nri.response_id();
}

message_id local_actor::timed_sync_send_tuple_impl(message_priority mp,
                                                   const actor& dest,
                                                   const util::duration& rtime,
                                                   any_tuple&& what) {
    auto nri = new_request_id();
    if (mp == message_priority::high) nri = nri.with_high_priority();
    dest->enqueue({address(), dest, nri}, std::move(what));
    auto rri = nri.response_id();
    get_scheduler()->delayed_send({address(), this, rri}, rtime,
                                  make_any_tuple(sync_timeout_msg{}));
    return rri;
}

 static void echo(actor<stackful>& self)
 {
   try
   {
     while (true)
     {
       message msg;
       aid_t sender = self.recv(msg);
       match_t type = msg.get_type();
       if (type == atom("echo"))
       {
         self.send(sender, msg);
       }
       else
       {
         break;
       }
     }
   }
   catch (std::exception& ex)
   {
     std::cerr << "echo except: " << ex.what() << std::endl;
   }
 }

message_id local_actor::timed_sync_send_tuple_impl(message_priority mp,
                                                   const actor& dest,
                                                   const util::duration& rtime,
                                                   any_tuple&& what) {
    if (!dest) {
        throw std::invalid_argument("cannot send synchronous message "
                                    "to invalid_actor");
    }
    auto nri = new_request_id();
    if (mp == message_priority::high) nri = nri.with_high_priority();
    dest->enqueue({address(), dest, nri}, std::move(what), m_host);
    auto rri = nri.response_id();
    get_scheduling_coordinator()->delayed_send({address(), this, rri}, rtime,
                                  make_any_tuple(sync_timeout_msg{}));
    return rri;
}

message_id local_actor::timed_sync_send_tuple_impl(message_priority mp,
                                                   const actor& dest,
                                                   const duration& rtime,
                                                   message&& what) {
  if (!dest) {
    throw std::invalid_argument(
      "cannot send synchronous message "
      "to invalid_actor");
  }
  auto nri = new_request_id();
  if (mp == message_priority::high) {
    nri = nri.with_high_priority();
  }
  dest->enqueue(address(), nri, std::move(what), host());
  auto rri = nri.response_id();
  auto sched_cd = detail::singletons::get_scheduling_coordinator();
  sched_cd->delayed_send(rtime, address(), this, rri,
                         make_message(sync_timeout_msg{}));
  return rri;
}

 /// Removes a monitor from `whom`.
 inline void demonitor(const actor& whom) {
   demonitor(whom.address());
 }

 /**
  * Sends an exit message to `whom`.
  */
 inline void send_exit(const actor& whom, uint32_t reason) {
   send_exit(whom.address(), reason);
 }