Source.Python forums

L'In20Cible wrote:

• Instead of having a function that call the spawn method on the passed player, you could simply delay that method to be called:
  

  Syntax: Select all

  Delay(cvars['autorespawn_delay'].get_int(), player.spawn)

  
  However, I would not recommend delaying any Player/Entity's method calls and/or passing them as argument. If the player leave the server/entity get removed before the call is made, you gonna either crash or your code will raise an error. In this specific case, I would rather recommend passing the index and recast the Player instance:
  
  

  Syntax: Select all

  # Into player_death...
  Delay(cvars['autorespawn_delay'].get_int(), respawn_player, player.index)
  
  def respawn_player(index):
      try:
          player = Player(index)
      except ValueError:
          # Player left the server, nothing to do here...
          return
      player.spawn()

  
  
  Another thing you should consider, is to store the Delay instances and cancel them on new round/map.

iPlayer wrote:Or, register OnEntityDeleted listener to cancel your delay for the specified entity.

satoon101 wrote:I would recommend this:

iPlayer wrote:Or, register OnEntityDeleted listener to cancel your delay for the specified entity.

It is 'possible' that during your delay, the entity is removed by other means. Not only that, but it is also 'possible' that after the entity was removed, another entity was created on the server and took the old entity's index. This means that if all you do is check that the entity index is valid, you could actually be removing the wrong entity.

from listeners.tick import Delay
from entities.entity import BaseEntity 

ENTITY_TARGET = "flashbang_projectile"

@OnEntityCreated
def on_entity_created(entity):
    if not entity.classname == ENTITY_TARGET:
        return
        
    Delay(1.2, entity_kill, entity.basehandle)

def entity_kill(handle):
    if not handle.is_valid():
        return
        
    BaseEntity(handle.entry_index).remove()

decompile wrote:Arent indexes & userids unique?

L'In20Cible wrote:For convenience, we could add an Entity.delay method that wrap the Delay class and internally cancel on entity deletion.

iPlayer wrote:Does that work with disconnecting clients? E.g. can't there be a case when a player has already disconnected, but their entity has yet to be removed or something? Other words, can I safely do this:

Syntax: Select all

player.delay(5.0, player.spawn)

? (omitting the "respawning a respawned player" issue)

iPlayer wrote:Also, one thing I've noticed in your commits. You have only used cancel_on_level_end flag in your commit to tick_update branch, and in the master branch such flag will implicitly go to kwargs dictionary.

Ayuto wrote:Cancelling the delay is probably the best choice. However, you could also use something like this.

Syntax: Select all

from listeners.tick import Delay
from entities.entity import BaseEntity 

ENTITY_TARGET = "flashbang_projectile"

@OnEntityCreated
def on_entity_created(entity):
    if not entity.classname == ENTITY_TARGET:
        return
        
    Delay(1.2, entity_kill, entity.basehandle)

def entity_kill(handle):
    if not handle.is_valid():
        return
        
    BaseEntity(handle.entry_index).remove()

decompile wrote:Arent indexes & userids unique?

Userids are unique, but indexes aren't.