26class Activity(DependencyComponent, Generic[PlayerT, TeamT]):
 27    """Units of execution wrangled by a bascenev1.Session.
 28
 29    Examples of Activities include games, score-screens, cutscenes, etc.
 30    A bascenev1.Session has one 'current' Activity at any time, though
 31    their existence can overlap during transitions.
 32    """
 33
 34    # pylint: disable=too-many-public-methods
 35
 36    settings_raw: dict[str, Any]
 37    """The settings dict passed in when the activity was made.
 38       This attribute is deprecated and should be avoided when possible;
 39       activities should pull all values they need from the 'settings' arg
 40       passed to the Activity __init__ call."""
 41
 42    teams: list[TeamT]
 43    """The list of bascenev1.Team-s in the Activity. This gets populated just
 44       before on_begin() is called and is updated automatically as players
 45       join or leave the game. (at least in free-for-all mode where every
 46       player gets their own team; in teams mode there are always 2 teams
 47       regardless of the player count)."""
 48
 49    players: list[PlayerT]
 50    """The list of bascenev1.Player-s in the Activity. This gets populated
 51       just before on_begin() is called and is updated automatically as
 52       players join or leave the game."""
 53
 54    announce_player_deaths = False
 55    """Whether to print every time a player dies. This can be pertinent
 56       in games such as Death-Match but can be annoying in games where it
 57       doesn't matter."""
 58
 59    is_joining_activity = False
 60    """Joining activities are for waiting for initial player joins.
 61       They are treated slightly differently than regular activities,
 62       mainly in that all players are passed to the activity at once
 63       instead of as each joins."""
 64
 65    allow_pausing = False
 66    """Whether game-time should still progress when in menus/etc."""
 67
 68    allow_kick_idle_players = True
 69    """Whether idle players can potentially be kicked (should not happen in
 70       menus/etc)."""
 71
 72    use_fixed_vr_overlay = False
 73    """In vr mode, this determines whether overlay nodes (text, images, etc)
 74       are created at a fixed position in space or one that moves based on
 75       the current map. Generally this should be on for games and off for
 76       transitions/score-screens/etc. that persist between maps."""
 77
 78    slow_motion = False
 79    """If True, runs in slow motion and turns down sound pitch."""
 80
 81    inherits_slow_motion = False
 82    """Set this to True to inherit slow motion setting from previous
 83       activity (useful for transitions to avoid hitches)."""
 84
 85    inherits_music = False
 86    """Set this to True to keep playing the music from the previous activity
 87       (without even restarting it)."""
 88
 89    inherits_vr_camera_offset = False
 90    """Set this to true to inherit VR camera offsets from the previous
 91       activity (useful for preventing sporadic camera movement
 92       during transitions)."""
 93
 94    inherits_vr_overlay_center = False
 95    """Set this to true to inherit (non-fixed) VR overlay positioning from
 96       the previous activity (useful for prevent sporadic overlay jostling
 97       during transitions)."""
 98
 99    inherits_tint = False
100    """Set this to true to inherit screen tint/vignette colors from the
101       previous activity (useful to prevent sudden color changes during
102       transitions)."""
103
104    allow_mid_activity_joins: bool = True
105    """Whether players should be allowed to join in the middle of this
106       activity. Note that Sessions may not allow mid-activity-joins even
107       if the activity says its ok."""
108
109    transition_time = 0.0
110    """If the activity fades or transitions in, it should set the length of
111       time here so that previous activities will be kept alive for that
112       long (avoiding 'holes' in the screen)
113       This value is given in real-time seconds."""
114
115    can_show_ad_on_death = False
116    """Is it ok to show an ad after this activity ends before showing
117       the next activity?"""
118
119    def __init__(self, settings: dict):
120        """Creates an Activity in the current bascenev1.Session.
121
122        The activity will not be actually run until
123        bascenev1.Session.setactivity is called. 'settings' should be a
124        dict of key/value pairs specific to the activity.
125
126        Activities should preload as much of their media/etc as possible in
127        their constructor, but none of it should actually be used until they
128        are transitioned in.
129        """
130        super().__init__()
131
132        # Create our internal engine data.
133        self._activity_data = _bascenev1.register_activity(self)
134
135        assert isinstance(settings, dict)
136        assert _bascenev1.getactivity() is self
137
138        self._globalsnode: bascenev1.Node | None = None
139
140        # Player/Team types should have been specified as type args;
141        # grab those.
142        self._playertype: type[PlayerT]
143        self._teamtype: type[TeamT]
144        self._setup_player_and_team_types()
145
146        # FIXME: Relocate or remove the need for this stuff.
147        self.paused_text: bascenev1.Actor | None = None
148
149        self._session = weakref.ref(_bascenev1.getsession())
150
151        # Preloaded data for actors, maps, etc; indexed by type.
152        self.preloads: dict[type, Any] = {}
153
154        # Hopefully can eventually kill this; activities should
155        # validate/store whatever settings they need at init time
156        # (in a more type-safe way).
157        self.settings_raw = settings
158
159        self._has_transitioned_in = False
160        self._has_begun = False
161        self._has_ended = False
162        self._activity_death_check_timer: bascenev1.AppTimer | None = None
163        self._expired = False
164        self._delay_delete_players: list[PlayerT] = []
165        self._delay_delete_teams: list[TeamT] = []
166        self._players_that_left: list[weakref.ref[PlayerT]] = []
167        self._teams_that_left: list[weakref.ref[TeamT]] = []
168        self._transitioning_out = False
169
170        # A handy place to put most actors; this list is pruned of dead
171        # actors regularly and these actors are insta-killed as the activity
172        # is dying.
173        self._actor_refs: list[bascenev1.Actor] = []
174        self._actor_weak_refs: list[weakref.ref[bascenev1.Actor]] = []
175        self._last_prune_dead_actors_time = babase.apptime()
176        self._prune_dead_actors_timer: bascenev1.Timer | None = None
177
178        self.teams = []
179        self.players = []
180
181        self.lobby = None
182        self._stats: bascenev1.Stats | None = None
183        self._customdata: dict | None = {}
184
185    def __del__(self) -> None:
186        # If the activity has been run then we should have already cleaned
187        # it up, but we still need to run expire calls for un-run activities.
188        if not self._expired:
189            with babase.ContextRef.empty():
190                self._expire()
191
192        # Inform our owner that we officially kicked the bucket.
193        if self._transitioning_out:
194            session = self._session()
195            if session is not None:
196                babase.pushcall(
197                    babase.Call(
198                        session.transitioning_out_activity_was_freed,
199                        self.can_show_ad_on_death,
200                    )
201                )
202
203    @property
204    def context(self) -> bascenev1.ContextRef:
205        """A context-ref pointing at this activity."""
206        return self._activity_data.context()
207
208    @property
209    def globalsnode(self) -> bascenev1.Node:
210        """The 'globals' bascenev1.Node for the activity. This contains various
211        global controls and values.
212        """
213        node = self._globalsnode
214        if not node:
215            raise babase.NodeNotFoundError()
216        return node
217
218    @property
219    def stats(self) -> bascenev1.Stats:
220        """The stats instance accessible while the activity is running.
221
222        If access is attempted before or after, raises a
223        bascenev1.NotFoundError.
224        """
225        if self._stats is None:
226            raise babase.NotFoundError()
227        return self._stats
228
229    def on_expire(self) -> None:
230        """Called when your activity is being expired.
231
232        If your activity has created anything explicitly that may be retaining
233        a strong reference to the activity and preventing it from dying, you
234        should clear that out here. From this point on your activity's sole
235        purpose in life is to hit zero references and die so the next activity
236        can begin.
237        """
238
239    @property
240    def customdata(self) -> dict:
241        """Entities needing to store simple data with an activity can put it
242        here. This dict will be deleted when the activity expires, so contained
243        objects generally do not need to worry about handling expired
244        activities.
245        """
246        assert not self._expired
247        assert isinstance(self._customdata, dict)
248        return self._customdata
249
250    @property
251    def expired(self) -> bool:
252        """Whether the activity is expired.
253
254        An activity is set as expired when shutting down.
255        At this point no new nodes, timers, etc should be made,
256        run, etc, and the activity should be considered a 'zombie'.
257        """
258        return self._expired
259
260    @property
261    def playertype(self) -> type[PlayerT]:
262        """The type of bascenev1.Player this Activity is using."""
263        return self._playertype
264
265    @property
266    def teamtype(self) -> type[TeamT]:
267        """The type of bascenev1.Team this Activity is using."""
268        return self._teamtype
269
270    def set_has_ended(self, val: bool) -> None:
271        """(internal)"""
272        self._has_ended = val
273
274    def expire(self) -> None:
275        """Begin the process of tearing down the activity.
276
277        (internal)
278        """
279
280        # Create an app-timer that watches a weak-ref of this activity
281        # and reports any lingering references keeping it alive.
282        # We store the timer on the activity so as soon as the activity dies
283        # it gets cleaned up.
284        with babase.ContextRef.empty():
285            ref = weakref.ref(self)
286            self._activity_death_check_timer = babase.AppTimer(
287                5.0,
288                babase.Call(self._check_activity_death, ref, [0]),
289                repeat=True,
290            )
291
292        # Run _expire in an empty context; nothing should be happening in
293        # there except deleting things which requires no context.
294        # (plus, _expire() runs in the destructor for un-run activities
295        # and we can't properly provide context in that situation anyway; might
296        # as well be consistent).
297        if not self._expired:
298            with babase.ContextRef.empty():
299                self._expire()
300        else:
301            raise RuntimeError(
302                f'destroy() called when already expired for {self}.'
303            )
304
305    def retain_actor(self, actor: bascenev1.Actor) -> None:
306        """Add a strong-reference to a bascenev1.Actor to this Activity.
307
308        The reference will be lazily released once bascenev1.Actor.exists()
309        returns False for the Actor. The bascenev1.Actor.autoretain() method
310        is a convenient way to access this same functionality.
311        """
312        if __debug__:
313            from bascenev1._actor import Actor
314
315            assert isinstance(actor, Actor)
316        self._actor_refs.append(actor)
317
318    def add_actor_weak_ref(self, actor: bascenev1.Actor) -> None:
319        """Add a weak-reference to a bascenev1.Actor to the bascenev1.Activity.
320
321        (called by the bascenev1.Actor base class)
322        """
323        if __debug__:
324            from bascenev1._actor import Actor
325
326            assert isinstance(actor, Actor)
327        self._actor_weak_refs.append(weakref.ref(actor))
328
329    @property
330    def session(self) -> bascenev1.Session:
331        """The bascenev1.Session this bascenev1.Activity belongs to.
332
333        Raises a :class:`~bascenev1.SessionNotFoundError` if the Session
334        no longer exists.
335        """
336        session = self._session()
337        if session is None:
338            raise babase.SessionNotFoundError()
339        return session
340
341    def on_player_join(self, player: PlayerT) -> None:
342        """Called when a new bascenev1.Player has joined the Activity.
343
344        (including the initial set of Players)
345        """
346
347    def on_player_leave(self, player: PlayerT) -> None:
348        """Called when a bascenev1.Player is leaving the Activity."""
349
350    def on_team_join(self, team: TeamT) -> None:
351        """Called when a new bascenev1.Team joins the Activity.
352
353        (including the initial set of Teams)
354        """
355
356    def on_team_leave(self, team: TeamT) -> None:
357        """Called when a bascenev1.Team leaves the Activity."""
358
359    def on_transition_in(self) -> None:
360        """Called when the Activity is first becoming visible.
361
362        Upon this call, the Activity should fade in backgrounds,
363        start playing music, etc. It does not yet have access to players
364        or teams, however. They remain owned by the previous Activity
365        up until bascenev1.Activity.on_begin() is called.
366        """
367
368    def on_transition_out(self) -> None:
369        """Called when your activity begins transitioning out.
370
371        Note that this may happen at any time even if bascenev1.Activity.end()
372        has not been called.
373        """
374
375    def on_begin(self) -> None:
376        """Called once the previous Activity has finished transitioning out.
377
378        At this point the activity's initial players and teams are filled in
379        and it should begin its actual game logic.
380        """
381
382    def handlemessage(self, msg: Any) -> Any:
383        """General message handling; can be passed any message object."""
384        del msg  # Unused arg.
385        return UNHANDLED
386
387    def has_transitioned_in(self) -> bool:
388        """Return whether bascenev1.Activity.on_transition_in() has run."""
389        return self._has_transitioned_in
390
391    def has_begun(self) -> bool:
392        """Return whether bascenev1.Activity.on_begin() has run."""
393        return self._has_begun
394
395    def has_ended(self) -> bool:
396        """Return whether the activity has commenced ending."""
397        return self._has_ended
398
399    def is_transitioning_out(self) -> bool:
400        """Return whether bascenev1.Activity.on_transition_out() has run."""
401        return self._transitioning_out
402
403    def transition_in(self, prev_globals: bascenev1.Node | None) -> None:
404        """Called by Session to kick off transition-in.
405
406        (internal)
407        """
408        assert not self._has_transitioned_in
409        self._has_transitioned_in = True
410
411        # Set up the globals node based on our settings.
412        with self.context:
413            glb = self._globalsnode = _bascenev1.newnode('globals')
414
415            # Now that it's going to be front and center,
416            # set some global values based on what the activity wants.
417            glb.use_fixed_vr_overlay = self.use_fixed_vr_overlay
418            glb.allow_kick_idle_players = self.allow_kick_idle_players
419            if self.inherits_slow_motion and prev_globals is not None:
420                glb.slow_motion = prev_globals.slow_motion
421            else:
422                glb.slow_motion = self.slow_motion
423            if self.inherits_music and prev_globals is not None:
424                glb.music_continuous = True  # Prevent restarting same music.
425                glb.music = prev_globals.music
426                glb.music_count += 1
427            if self.inherits_vr_camera_offset and prev_globals is not None:
428                glb.vr_camera_offset = prev_globals.vr_camera_offset
429            if self.inherits_vr_overlay_center and prev_globals is not None:
430                glb.vr_overlay_center = prev_globals.vr_overlay_center
431                glb.vr_overlay_center_enabled = (
432                    prev_globals.vr_overlay_center_enabled
433                )
434
435            # If they want to inherit tint from the previous self.
436            if self.inherits_tint and prev_globals is not None:
437                glb.tint = prev_globals.tint
438                glb.vignette_outer = prev_globals.vignette_outer
439                glb.vignette_inner = prev_globals.vignette_inner
440
441            # Start pruning our various things periodically.
442            self._prune_dead_actors()
443            self._prune_dead_actors_timer = _bascenev1.Timer(
444                5.17, self._prune_dead_actors, repeat=True
445            )
446
447            _bascenev1.timer(13.3, self._prune_delay_deletes, repeat=True)
448
449            # Also start our low-level scene running.
450            self._activity_data.start()
451
452            try:
453                self.on_transition_in()
454            except Exception:
455                logging.exception('Error in on_transition_in for %s.', self)
456
457        # Tell the C++ layer that this activity is the main one, so it uses
458        # settings from our globals, directs various events to us, etc.
459        self._activity_data.make_foreground()
460
461    def transition_out(self) -> None:
462        """Called by the Session to start us transitioning out."""
463        assert not self._transitioning_out
464        self._transitioning_out = True
465        with self.context:
466            try:
467                self.on_transition_out()
468            except Exception:
469                logging.exception('Error in on_transition_out for %s.', self)
470
471    def begin(self, session: bascenev1.Session) -> None:
472        """Begin the activity.
473
474        (internal)
475        """
476
477        assert not self._has_begun
478
479        # Inherit stats from the session.
480        self._stats = session.stats
481
482        # Add session's teams in.
483        for team in session.sessionteams:
484            self.add_team(team)
485
486        # Add session's players in.
487        for player in session.sessionplayers:
488            self.add_player(player)
489
490        self._has_begun = True
491
492        # Let the activity do its thing.
493        with self.context:
494            # Note: do we want to catch errors here?
495            # Currently I believe we wind up canceling the
496            # activity launch; just wanna be sure that is intentional.
497            self.on_begin()
498
499    def end(
500        self, results: Any = None, delay: float = 0.0, force: bool = False
501    ) -> None:
502        """Commences Activity shutdown and delivers results to the Session.
503
504        'delay' is the time delay before the Activity actually ends
505        (in seconds). Further calls to end() will be ignored up until
506        this time, unless 'force' is True, in which case the new results
507        will replace the old.
508        """
509
510        # Ask the session to end us.
511        self.session.end_activity(self, results, delay, force)
512
513    def create_player(self, sessionplayer: bascenev1.SessionPlayer) -> PlayerT:
514        """Create the Player instance for this Activity.
515
516        Subclasses can override this if the activity's player class
517        requires a custom constructor; otherwise it will be called with
518        no args. Note that the player object should not be used at this
519        point as it is not yet fully wired up; wait for
520        bascenev1.Activity.on_player_join() for that.
521        """
522        del sessionplayer  # Unused.
523        player = self._playertype()
524        return player
525
526    def create_team(self, sessionteam: bascenev1.SessionTeam) -> TeamT:
527        """Create the Team instance for this Activity.
528
529        Subclasses can override this if the activity's team class
530        requires a custom constructor; otherwise it will be called with
531        no args. Note that the team object should not be used at this
532        point as it is not yet fully wired up; wait for on_team_join()
533        for that.
534        """
535        del sessionteam  # Unused.
536        team = self._teamtype()
537        return team
538
539    def add_player(self, sessionplayer: bascenev1.SessionPlayer) -> None:
540        """(internal)"""
541        assert sessionplayer.sessionteam is not None
542        sessionplayer.resetinput()
543        sessionteam = sessionplayer.sessionteam
544        assert sessionplayer in sessionteam.players
545        team = sessionteam.activityteam
546        assert team is not None
547        sessionplayer.setactivity(self)
548        with self.context:
549            sessionplayer.activityplayer = player = self.create_player(
550                sessionplayer
551            )
552            player.postinit(sessionplayer)
553
554            assert player not in team.players
555            team.players.append(player)
556            assert player in team.players
557
558            assert player not in self.players
559            self.players.append(player)
560            assert player in self.players
561
562            try:
563                self.on_player_join(player)
564            except Exception:
565                logging.exception('Error in on_player_join for %s.', self)
566
567    def remove_player(self, sessionplayer: bascenev1.SessionPlayer) -> None:
568        """Remove a player from the Activity while it is running.
569
570        (internal)
571        """
572        assert not self.expired
573
574        player: Any = sessionplayer.activityplayer
575        assert isinstance(player, self._playertype)
576        team: Any = sessionplayer.sessionteam.activityteam
577        assert isinstance(team, self._teamtype)
578
579        assert player in team.players
580        team.players.remove(player)
581        assert player not in team.players
582
583        assert player in self.players
584        self.players.remove(player)
585        assert player not in self.players
586
587        # This should allow our bascenev1.Player instance to die.
588        # Complain if that doesn't happen.
589        # verify_object_death(player)
590
591        with self.context:
592            try:
593                self.on_player_leave(player)
594            except Exception:
595                logging.exception('Error in on_player_leave for %s.', self)
596            try:
597                player.leave()
598            except Exception:
599                logging.exception('Error on leave for %s in %s.', player, self)
600
601            self._reset_session_player_for_no_activity(sessionplayer)
602
603        # Add the player to a list to keep it around for a while. This is
604        # to discourage logic from firing on player object death, which
605        # may not happen until activity end if something is holding refs
606        # to it.
607        self._delay_delete_players.append(player)
608        self._players_that_left.append(weakref.ref(player))
609
610    def add_team(self, sessionteam: bascenev1.SessionTeam) -> None:
611        """Add a team to the Activity
612
613        (internal)
614        """
615        assert not self.expired
616
617        with self.context:
618            sessionteam.activityteam = team = self.create_team(sessionteam)
619            team.postinit(sessionteam)
620            self.teams.append(team)
621            try:
622                self.on_team_join(team)
623            except Exception:
624                logging.exception('Error in on_team_join for %s.', self)
625
626    def remove_team(self, sessionteam: bascenev1.SessionTeam) -> None:
627        """Remove a team from a Running Activity
628
629        (internal)
630        """
631        assert not self.expired
632        assert sessionteam.activityteam is not None
633
634        team: Any = sessionteam.activityteam
635        assert isinstance(team, self._teamtype)
636
637        assert team in self.teams
638        self.teams.remove(team)
639        assert team not in self.teams
640
641        with self.context:
642            # Make a decent attempt to persevere if user code breaks.
643            try:
644                self.on_team_leave(team)
645            except Exception:
646                logging.exception('Error in on_team_leave for %s.', self)
647            try:
648                team.leave()
649            except Exception:
650                logging.exception('Error on leave for %s in %s.', team, self)
651
652            sessionteam.activityteam = None
653
654        # Add the team to a list to keep it around for a while. This is
655        # to discourage logic from firing on team object death, which
656        # may not happen until activity end if something is holding refs
657        # to it.
658        self._delay_delete_teams.append(team)
659        self._teams_that_left.append(weakref.ref(team))
660
661    def _reset_session_player_for_no_activity(
662        self, sessionplayer: bascenev1.SessionPlayer
663    ) -> None:
664        # Let's be extra-defensive here: killing a node/input-call/etc
665        # could trigger user-code resulting in errors, but we would still
666        # like to complete the reset if possible.
667        try:
668            sessionplayer.setnode(None)
669        except Exception:
670            logging.exception(
671                'Error resetting SessionPlayer node on %s for %s.',
672                sessionplayer,
673                self,
674            )
675        try:
676            sessionplayer.resetinput()
677        except Exception:
678            logging.exception(
679                'Error resetting SessionPlayer input on %s for %s.',
680                sessionplayer,
681                self,
682            )
683
684        # These should never fail I think...
685        sessionplayer.setactivity(None)
686        sessionplayer.activityplayer = None
687
688    # noinspection PyUnresolvedReferences
689    def _setup_player_and_team_types(self) -> None:
690        """Pull player and team types from our typing.Generic params."""
691
692        # TODO: There are proper calls for pulling these in Python 3.8;
693        # should update this code when we adopt that.
694        # NOTE: If we get Any as PlayerT or TeamT (generally due
695        # to no generic params being passed) we automatically use the
696        # base class types, but also warn the user since this will mean
697        # less type safety for that class. (its better to pass the base
698        # player/team types explicitly vs. having them be Any)
699        if not TYPE_CHECKING:
700            self._playertype = type(self).__orig_bases__[-1].__args__[0]
701            if not isinstance(self._playertype, type):
702                self._playertype = Player
703                print(
704                    f'ERROR: {type(self)} was not passed a Player'
705                    f' type argument; please explicitly pass bascenev1.Player'
706                    f' if you do not want to override it.'
707                )
708            self._teamtype = type(self).__orig_bases__[-1].__args__[1]
709            if not isinstance(self._teamtype, type):
710                self._teamtype = Team
711                print(
712                    f'ERROR: {type(self)} was not passed a Team'
713                    f' type argument; please explicitly pass bascenev1.Team'
714                    f' if you do not want to override it.'
715                )
716        assert issubclass(self._playertype, Player)
717        assert issubclass(self._teamtype, Team)
718
719    @classmethod
720    def _check_activity_death(
721        cls, activity_ref: weakref.ref[Activity], counter: list[int]
722    ) -> None:
723        """Sanity check to make sure an Activity was destroyed properly.
724
725        Receives a weakref to a bascenev1.Activity which should have torn
726        itself down due to no longer being referenced anywhere. Will complain
727        and/or print debugging info if the Activity still exists.
728        """
729        try:
730            activity = activity_ref()
731            print(
732                'ERROR: Activity is not dying when expected:',
733                activity,
734                '(warning ' + str(counter[0] + 1) + ')',
735            )
736            print(
737                'This means something is still strong-referencing it.\n'
738                'Check out methods such as efro.debug.printrefs() to'
739                ' help debug this sort of thing.'
740            )
741            # Note: no longer calling gc.get_referrers() here because it's
742            # usage can bork stuff. (see notes at top of efro.debug)
743            counter[0] += 1
744            if counter[0] == 4:
745                print('Killing app due to stuck activity... :-(')
746                babase.quit()
747
748        except Exception:
749            logging.exception('Error on _check_activity_death.')
750
751    def _expire(self) -> None:
752        """Put the activity in a state where it can be garbage-collected.
753
754        This involves clearing anything that might be holding a reference
755        to it, etc.
756        """
757        assert not self._expired
758        self._expired = True
759
760        try:
761            self.on_expire()
762        except Exception:
763            logging.exception('Error in Activity on_expire() for %s.', self)
764
765        try:
766            self._customdata = None
767        except Exception:
768            logging.exception('Error clearing customdata for %s.', self)
769
770        # Don't want to be holding any delay-delete refs at this point.
771        self._prune_delay_deletes()
772
773        self._expire_actors()
774        self._expire_players()
775        self._expire_teams()
776
777        # This will kill all low level stuff: Timers, Nodes, etc., which
778        # should clear up any remaining refs to our Activity and allow us
779        # to die peacefully.
780        try:
781            self._activity_data.expire()
782        except Exception:
783            logging.exception('Error expiring _activity_data for %s.', self)
784
785    def _expire_actors(self) -> None:
786        # Expire all Actors.
787        for actor_ref in self._actor_weak_refs:
788            actor = actor_ref()
789            if actor is not None:
790                babase.verify_object_death(actor)
791                try:
792                    actor.on_expire()
793                except Exception:
794                    logging.exception(
795                        'Error in Actor.on_expire() for %s.', actor_ref()
796                    )
797
798    def _expire_players(self) -> None:
799        # Issue warnings for any players that left the game but don't
800        # get freed soon.
801        for ex_player in (p() for p in self._players_that_left):
802            if ex_player is not None:
803                babase.verify_object_death(ex_player)
804
805        for player in self.players:
806            # This should allow our bascenev1.Player instance to be freed.
807            # Complain if that doesn't happen.
808            babase.verify_object_death(player)
809
810            try:
811                player.expire()
812            except Exception:
813                logging.exception('Error expiring %s.', player)
814
815            # Reset the SessionPlayer to a not-in-an-activity state.
816            try:
817                sessionplayer = player.sessionplayer
818                self._reset_session_player_for_no_activity(sessionplayer)
819            except babase.SessionPlayerNotFoundError:
820                # Conceivably, someone could have held on to a Player object
821                # until now whos underlying SessionPlayer left long ago...
822                pass
823            except Exception:
824                logging.exception('Error expiring %s.', player)
825
826    def _expire_teams(self) -> None:
827        # Issue warnings for any teams that left the game but don't
828        # get freed soon.
829        for ex_team in (p() for p in self._teams_that_left):
830            if ex_team is not None:
831                babase.verify_object_death(ex_team)
832
833        for team in self.teams:
834            # This should allow our bascenev1.Team instance to die.
835            # Complain if that doesn't happen.
836            babase.verify_object_death(team)
837
838            try:
839                team.expire()
840            except Exception:
841                logging.exception('Error expiring %s.', team)
842
843            try:
844                sessionteam = team.sessionteam
845                sessionteam.activityteam = None
846            except babase.SessionTeamNotFoundError:
847                # It is expected that Team objects may last longer than
848                # the SessionTeam they came from (game objects may hold
849                # team references past the point at which the underlying
850                # player/team has left the game)
851                pass
852            except Exception:
853                logging.exception('Error expiring Team %s.', team)
854
855    def _prune_delay_deletes(self) -> None:
856        self._delay_delete_players.clear()
857        self._delay_delete_teams.clear()
858
859        # Clear out any dead weak-refs.
860        self._teams_that_left = [
861            t for t in self._teams_that_left if t() is not None
862        ]
863        self._players_that_left = [
864            p for p in self._players_that_left if p() is not None
865        ]
866
867    def _prune_dead_actors(self) -> None:
868        self._last_prune_dead_actors_time = babase.apptime()
869
870        # Prune our strong refs when the Actor's exists() call gives False
871        self._actor_refs = [a for a in self._actor_refs if a.exists()]
872
873        # Prune our weak refs once the Actor object has been freed.
874        self._actor_weak_refs = [
875            a for a in self._actor_weak_refs if a() is not None
876        ]