Have the actor evaluate the end of turn for itself only.
331666
def _score_eot_for_actor(self, eot, actor):
        """"""
        # currently just simple sum of own attributes
        # could be much more sophisticated in both analysis (e.g. formulas)
        # and breadth of items analyzed (e.g. require other actor, the board)
        end_state = eot.parent
        a = {'player': end_state.player,
             'opponent': end_state.opponent}[actor.name]
        # simple prioritization without regard to character attributes
        health = a.health * 2
        r, g, b, y = a.r, a.g, a.b, a.y
        x, m = 0.5 * a.x, 0.5 * a.m
        return sum((health, r, g, b, y, x, m))
508338
protected void remoteRefStopped(Actor actor) {
        removeRemoteActor(actor);
        actor.getActorRef().__stopped = true;
        actor.getActor().__stopped = true;
    }
90474
void stop(final Actor actor) {
    final Actor removedActor = directory.remove(actor.address());

    if (actor == removedActor) {
      removedActor.lifeCycle.stop(actor);
    }
  }
1063610
def stop(self):
        """"""
        if self.state == PygAnimation.PLAYING:
            self.index = 0  # set up for first image in list
            self.elapsed = 0
            self.nIterationsLeft = 0

        elif self.state == PygAnimation.STOPPED:
            pass  # nothing to do

        elif self.state == PygAnimation.PAUSED:
            self.index = 0  # set up for first image in list
            self.elapsed = 0

        self.state = PygAnimation.STOPPED
716764
def end(self):
        """"""
        with self.__lock:
            if self.__write:
                self.__write(compress_end(self.__ctx))
            else:
                return compress_end(self.__ctx)
174250
def do_execute(self):
        

        result = None
        self._stopped = False
        self._stopping = False

        for actor in self.owner.actors:
            if self.is_stopping() or self.is_stopped():
                break
            actor.input = self.owner.input
            result = actor.execute()
            if result is not None:
                break

        return result
176904
def end(self):
        """"""
        for depth in xrange(len(self.names) - 1, -1, -1):
            self.out_f.write('{0}}}\n'.format(self.prefix(depth)))
613939
def end(self):
        """"""
        if hasattr(curses, 'echo'):
            curses.echo()
        if hasattr(curses, 'nocbreak'):
            curses.nocbreak()
        if hasattr(curses, 'curs_set'):
            try:
                curses.curs_set(1)
            except Exception:
                pass
        curses.endwin()
1146460
def pospawn(self, pawn):
        
        if self._turn < pawn.thing['arrival_time']:
            # It's weird that the pawn is getting placed in me, but
            # I'll do my best..
            pawn.pos = self.pos_along(0)
            return
        elif (
                pawn.thing['next_arrival_time'] and
                self._turn >= pawn.thing['next_arrival_time']
        ):
            pawn.pos = self.pos_along(1)
            return
        try:
            pawn.pos = self.pos_along(
                (
                    self._turn -
                    pawn.thing['arrival_time']
                ) / (
                    pawn.thing['next_arrival_time'] -
                    pawn.thing['arrival_time']
                )
            )
        except (TypeError, ZeroDivisionError):
            pawn.pos = self.pos_along(0)
583453
function pause () {
        triggerEvent('pause');
        stopLoop(animationId);
        pausedAfter = startTime - performance.now();
        startTime = undefined;
        return self;
      }
809655
def exit_actor():
    
    worker = ray.worker.global_worker
    if worker.mode == ray.WORKER_MODE and not worker.actor_id.is_nil():
        # Disconnect the worker from the raylet. The point of
        # this is so that when the worker kills itself below, the
        # raylet won't push an error message to the driver.
        worker.raylet_client.disconnect()
        ray.disconnect()
        # Disconnect global state from GCS.
        ray.global_state.disconnect()
        sys.exit(0)
        assert False, "This process should have terminated."
    else:
        raise Exception("exit_actor called on a non-actor worker.")
1308373
def last_active(self):
        
        result = None
        for actor in reversed(self.actors):
            if not actor.skip:
                result = actor
                break
        return result
415352
def _handle_end_way(self):
        
        self._result.append(Way(result=self._result, **self._curr))
        self._curr = {}
757976
def choose(self):
        """"""
        if not self.choosed:
            self.choosed = True
            self.pos = self.pos + Sep(5, 0)
1275968
function (e, onlyAbsolute) {
			var current = F.current,
				wrap    = current ? current.wrap : null,
				pos;

			if (wrap) {
				pos = F._getPosition(onlyAbsolute);

				if (e && e.type === 'scroll') {
					delete pos.position;

					wrap.stop(true, true).animate(pos, 200);

				} else {
					wrap.css(pos);

					current.pos = $.extend({}, current.dim, pos);
				}
			}
		}
1227813
def stop_execution(self):
        
        if not (self._stopping or self._stopped):
            for actor in self.owner.actors:
                actor.stop_execution()
            self._stopping = True
1297738
def wrapup(self):
        
        for actor in self.actors:
            if actor.skip:
                continue
            actor.wrapup()
        super(ActorHandler, self).wrapup()