mirror of
https://github.com/ParadiseSS13/Paradise.git
synced 2025-12-20 07:12:55 +00:00
bbca8405ef
This commit ports /tg/'s move refactor. The throwing system has been replaced entirely, removing the necessity of throw_at_fast and resolving multiple outstanding issues, such as crossbows being unusable. Spacedrifting has also been upgraded to function with the new throwing system. It is now it's own process. Tickcomp has been killed, and the config values have been adjusted to more or less match live Paradise. All mobs now share a common Bump() proc. There are only four mobtypes which do not, including humans and simple animals. With the exception of mob types that do not ever want to Bump() or be Bumped(), they should call the parent proc. Human movement slowdown has been moderately tweaked in how it stacks effects; It shouldn't be significantly different from a player perspective. Mobs will now spread fire if they bump into another mob. I don't want to set the world on fiiiire, I just want start a flame in your heart~ For player facing changes: Input delay has been reduced by roughly ~50ms for any direction keys, by advantage of a previously unknown flag on byond verbs which allow them to operate independently from the tick rate of the server. You may need to clear your interface.dmf file if you have a custom skin for this change to function.
99 lines
3.1 KiB
Plaintext
99 lines
3.1 KiB
Plaintext
/*
|
|
USAGE:
|
|
|
|
var/datum/callback/C = new(object|null, /proc/type/path|"procstring", arg1, arg2, ... argn)
|
|
var/timerid = addtimer(C, time, timertype)
|
|
OR
|
|
var/timerid = addtimer(CALLBACK(object|null, /proc/type/path|procstring, arg1, arg2, ... argn), time, timertype)
|
|
|
|
Note: proc strings can only be given for datum proc calls, global procs must be proc paths
|
|
Also proc strings are strongly advised against because they don't compile error if the proc stops existing
|
|
See the note on proc typepath shortcuts
|
|
|
|
INVOKING THE CALLBACK:
|
|
var/result = C.Invoke(args, to, add) //additional args are added after the ones given when the callback was created
|
|
OR
|
|
var/result = C.InvokeAsync(args, to, add) //Sleeps will not block, returns . on the first sleep (then continues on in the "background" after the sleep/block ends), otherwise operates normally.
|
|
OR
|
|
INVOKE_ASYNC(<CALLBACK args>) to immediately create and call InvokeAsync
|
|
|
|
PROC TYPEPATH SHORTCUTS (these operate on paths, not types, so to these shortcuts, datum is NOT a parent of atom, etc...)
|
|
|
|
global proc while in another global proc:
|
|
.procname
|
|
Example:
|
|
CALLBACK(GLOBAL_PROC, .some_proc_here)
|
|
|
|
proc defined on current(src) object (when in a /proc/ and not an override) OR overridden at src or any of it's parents:
|
|
.procname
|
|
Example:
|
|
CALLBACK(src, .some_proc_here)
|
|
|
|
|
|
when the above doesn't apply:
|
|
.proc/procname
|
|
Example:
|
|
CALLBACK(src, .proc/some_proc_here)
|
|
|
|
proc defined on a parent of a some type:
|
|
/some/type/.proc/some_proc_here
|
|
|
|
|
|
|
|
Other wise you will have to do the full typepath of the proc (/type/of/thing/proc/procname)
|
|
|
|
*/
|
|
|
|
/datum/callback
|
|
var/datum/object = GLOBAL_PROC
|
|
var/delegate
|
|
var/list/arguments
|
|
|
|
/datum/callback/New(thingtocall, proctocall, ...)
|
|
if(thingtocall)
|
|
object = thingtocall
|
|
delegate = proctocall
|
|
if(length(args) > 2)
|
|
arguments = args.Copy(3)
|
|
|
|
/proc/ImmediateInvokeAsync(thingtocall, proctocall, ...)
|
|
set waitfor = FALSE
|
|
|
|
if(!thingtocall)
|
|
return
|
|
|
|
var/list/calling_arguments = length(args) > 2 ? args.Copy(3) : null
|
|
|
|
if(thingtocall == GLOBAL_PROC)
|
|
call(proctocall)(arglist(calling_arguments))
|
|
else
|
|
call(thingtocall, proctocall)(arglist(calling_arguments))
|
|
|
|
/datum/callback/proc/Invoke(...)
|
|
if(!object)
|
|
return
|
|
var/list/calling_arguments = arguments
|
|
if(length(args))
|
|
if(length(arguments))
|
|
calling_arguments = calling_arguments + args //not += so that it creates a new list so the arguments list stays clean
|
|
else
|
|
calling_arguments = args
|
|
if(object == GLOBAL_PROC)
|
|
return call(delegate)(arglist(calling_arguments))
|
|
return call(object, delegate)(arglist(calling_arguments))
|
|
|
|
//copy and pasted because fuck proc overhead
|
|
/datum/callback/proc/InvokeAsync(...)
|
|
set waitfor = FALSE
|
|
if(!object)
|
|
return
|
|
var/list/calling_arguments = arguments
|
|
if(length(args))
|
|
if(length(arguments))
|
|
calling_arguments = calling_arguments + args //not += so that it creates a new list so the arguments list stays clean
|
|
else
|
|
calling_arguments = args
|
|
if(object == GLOBAL_PROC)
|
|
return call(delegate)(arglist(calling_arguments))
|
|
return call(object, delegate)(arglist(calling_arguments))
|