Source.Python forums

int(es.entitygetvalue(index, 'mykey'))

def fire(*args):
	args = list(args)
	if not (isinstance(args[0], int) and es.exists('userid', args[0])):
		args.insert(0, es.getuserid())
	
	args = args[:5]
	es.fire(*args)

es.server.queuecmd('es_xfire %s' % ' '.join(map(str, args)))

fire(userid, '*', 'SetParent', '!activator')

model = entity.get_keyvalue_string('model')

entity.call_input(name, value=None, caller=None, activator=None)

entity.set_parent(other_entity, -1) # -1 being the attachment index, see studio package for more info.

entity.call_input(name, value=None, caller=None, activator=None)

[

	# entities list
	# ...
	
	{
		"id": "577",
		"classname": "jb_game_control",
		"game": "singlewinner_koth",

		# some unrelated key-values
		# ...

		"targetname": "koth_game_control",
		"connections": {
			"OnStart": [
				"koth_spotlight,LightOn,,0,-1",
				"koth_music,Volume,10,0,-1",
				"koth_timer,Enable,,0,-1",
			],
			"OnEnd": [
				"koth_spotlight,LightOff,,0,-1",
				"koth_music,Volume,0,0,-1",
				"koth_timer,Disable,,0,-1",
			],
		},
		"origin": "392 488 8",

		# more unrelated key-values
		# ...

	}
]

player.client_command("ent_fire func_door Open", server_side=True)
player.client_command("ent_fire * SetParent !activator", server_side=True)    # Nasty stuff

def fire(source, target_pattern, input_name, parameter=None):
    if target_pattern.startswith('!'):
        if target_pattern not in ("!caller", "!activator", "!self"):
            return
        
        if source is None:
            return
        
        targets = (source, )
    
    else:
        targets = []
        if target_pattern.endswith('*'):    # Name searching supports trailing * wildcards only
            target_pattern = target_pattern[:-1]
            check_whole_string = False
        else:
            if not target_pattern:
                return
            
            check_whole_string = True
        
        if check_whole_string:
            for entity in EntityIter():
                if target_pattern in (getattr(entity, 'target_name', ""), entity.classname):
                    targets.append(entity)
        
        else:
            for entity in EntityIter():
                if (getattr(entity, 'target_name', "").startswith(target_pattern) or
                        entity.classname.startswith(target_pattern)):
                    
                    targets.append(entity)
    
    source_index = None if source is None else source.index
    for target in targets:
        try:
            target.call_input(input_name, value=parameter, caller=source_index)
        
        except ValueError:
            continue

from filters.entities import EntityIter
from listeners.tick import tick_delays


# fire() definition from the above message


class OutputConnection:
    def __init__(self, destroy_func, string):
        try:
            target_pattern, input_name, parameter, delay, times_to_fire = string.split(',')
        except ValueError:
            raise ValueError("Invalid output connection string")
        
        delay = max(0.0, float(delay))
        times_to_fire = max(-1, int(times_to_fire))
        
        self._destroy_func = destroy_func
        
        self.target_pattern = target_pattern
        self.input_name = input_name
        self.parameter = parameter or None
        self.delay = delay
        self.times_to_fire = times_to_fire
        
        self._delayed_callbacks = []
        self._times_fired = 0
    
    def reset(self):
        for delayed_callback in self._delayed_callbacks:
            try:
                delayed_callback.cancel()
            except KeyError:
                continue
        
        self._delayed_callbacks = []
        self._times_fired = 0
    
    def fire(self):
        if self.times_to_fire > -1 and self._times_fired >= self.times_to_fire:
            return
        
        self._times_fired += 1
        
        if self.delay == 0.0:
            fire(None, self.target_pattern, self.input_name, self.parameter)
        
        else:
            def callback():
                fire(None, self.target_pattern, self.input_name, self.parameter)
            
            self._delayed_callbacks.append(tick_delays.delay(self.delay, callback))
    
    def destroy(self):
        self._destroy_func(self)
    
    def __str__(self):
        return "OutputConnection('{0},{1},{2},{3},{4}')".format(
            self.target_pattern, self.input_name, self.parameter or "", self.delay, self.times_to_fire
        )


output_connections = []
def new_output_connection(string):
    output_connection = OutputConnection(destroy_output_connection, string)
    output_connections.append(output_connection)
    return output_connection


def destroy_output_connection(output_connection):
    output_connections.remove(output_connection)


def on_round_start(game_event):    # Event handler for "round_start"
    for output_connection in output_connections:
        output_connection.reset()

connection = new_output_connection("koth_spotlight,LightOn,,0,-1")
connection.fire()
connection.destroy()

input_function = target.get_input(input_name)
input_data = InputData()

if caller is not None:
	input_data.caller = caller.index

if activator is not None:
	input_data.activator = activator.index

if parameter is not None:
	input_data.value.set_string(parameter)    # Parameter is always string here, so this line will never raise ValueError

Function.__call__(input_function, input_function._this, input_data)

_input_types = {
    FieldType.BOOLEAN: bool,
    FieldType.FLOAT: float,
    FieldType.INTEGER: int,
    FieldType.STRING: str,
}

...

    for target in targets:
        input_function = target.get_input(input_name)
        
        caller_index = None if caller is None else caller.index
        activator_index = None if activator is None else activator.index
        
        if parameter is not None:
            type_ = _input_types.get(input_function._argument_type)
            
            # Check if type is unsupported, but we actually support all types that can possibly
            # be passed as a string to input: int, float, bool, string
            # TODO: Implement support for entities (passed as a special name like !activator, !caller etc)
            if type_ is None:
                continue
            
            # Try to cast the parameter to the given type
            try:
                parameter = type_(parameter)
            
            # We don't give up the target if the value can't be casted;
            # Instead, we fire its input with a default value just like ent_fire does
            except ValueError:
                parameter = type_()
        
        input_function(parameter, caller_index, activator_index)