Source.Python forums

from filters.entities import EntityIter


def dump_entity(classname):
    print("Number of '{0}' entities on the map: {1}".format(classname, len(EntityIter(classname))))


def load():
    dump_entity("func_button")
    dump_entity("prop_dynamic")
    dump_entity("math_counter")

from entities.classes import server_classes
from entities.datamaps import FieldType
from memory import make_object


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


def get_input(target, input_name):
    """Build an input function based on target's edict."""
    for server_class in server_classes.get_entity_server_classes(target):
        if input_name in server_class.inputs:
            return getattr(
                        make_object(server_class._inputs, target.pointer), input_name)
    
    return None


def call_input(target, input_name, parameter, caller, activator):
    """Call an input function"""
    # We are not sure if the entity actually supports this input
    input_function = get_input(target, input_name)
    
    # If not, we don't work with this entity
    if input_function is None:
        return
    
    caller_index = None if caller is None else caller.index
    activator_index = None if activator is None else activator.index
    
    # Check if type is unsupported, but we actually support all types that can possibly
    # be passed as a string to input: int, float, bool, str
    if input_function._argument_type not in _input_types:
        return
    
    type_ = _input_types[input_function._argument_type]
    
    # Case: input does not require parameter
    if type_ is None:
        parameter = None
    
    # Case: input does require parameter
    else:
        # 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_()
    
    # Fire an input
    input_function(parameter, caller_index, activator_index)