exec: Functions that a player or user can execute by typing its name in the console. link
final: This function can't be overridden in subclasses or states of this class. Functions that are static and final are automatically simulated as well.
latent: Latent functions require some time to be executed. Latent functions have to be native. link
native: The function is written in native C++ code.
simulated: The function can be executed on the server or a client in a network game. Any function not declared simulated is ignored on the client. Non-simulated functions in an Actor-derived class cannot be executed on a client in a network game, except in some special cases where the client owning that actor is the authority on that actor. link
singular: Prevents reentrancy (recursively calling the same function, in the same object). It can be very useful to prevent certain types of 'endless recursion loop' crashes, but it usefulness is limited by a few caveats. When an object enters a singular function, a flag is set on the object itself that prevents it from re-entering a singular function. This means that any other singular functions that are called on that object will not be executed until the initial singular function has returned, and the 'i'm in a singular function' flag has been unset on the object.
static: Static functions are functions which may be called without an object or actor. Instead, they are called on the class itself. Static functions can only access variables passed to them as parameters or the default values of variables. The only function calls that can be made from a static function are other static functions. link
protected: The function is only visible from the class it was declared in and in all subclasses.
private: The function is only visible from the class it was declared in, but not in any of its subclasses.
server: Declares that a function should be sent to the server for execution instead of running on the local client.
client: Declares that a function should be sent to the owning client for execution instead of running on the server. This flag also implicitly sets the simulated flag for the function.
reliable: Declares that a replicated function (marked with either server or client) should be reliably sent, meaning it will always eventually reach the other end in order relative to other replication on that Actor.
unreliable: Declares that a replicated function (marked with either server or client) should be unreliably sent, meaning that it is not guaranteed to reach the other end in any particular order or at all and may be skipped completely if there is insufficient bandwidth available.
delegate: A delegates is a reference to a function bound to an object. Their main use is to provide a callback mechanism, for example to provide event notification in a user interface system. link
Replication - replication statements have changed in UE3: The replication block is only used for variables now. Function replication is now defined by means of function specifiers (server, client, reliable). Variables declared with repnotify and defined in the replication session trigger simulated event ReplicatedEvent when they are changed.
When a function call is replicated all the parameters are replicated as well. The usual pitfalls apply, i.e. replicated actor references are only valid if the actor actually exists on the client, basic variable types, enums and structs will be replicated, while dynamic arrays won't. Of course you can only access other actors if they actually exist, i.e. if you are on the server or the actor is relevant to the client. If you pass a client-side actor as the parameter of a function replicated to the server, this parameter will be None on the server for obvious reasons.
An "Event" is a type of message sent during the game by one Actor to other actors. Every event has a name, chosen by the mapper or coder. Certain conditions will make an Actor "call" an event; and some Actors are "listening" for a particular event name to be called, and when it does they will react in some way.
Timer functions link
Timer functions are only available to Actor subclasses. You can create multiple timers with each a different rate. Each timer has a unique target function (defaults to Timer()).