From 468b14a01139e397f6482e198c3935ad5c3c11d8 Mon Sep 17 00:00:00 2001 From: LetterJay Date: Wed, 2 Aug 2017 06:04:43 -0500 Subject: [PATCH] Update component.dm --- code/datums/components/component.dm | 168 +++++++++++++++++++++------- 1 file changed, 126 insertions(+), 42 deletions(-) diff --git a/code/datums/components/component.dm b/code/datums/components/component.dm index b9212d2786..5e25a581f8 100644 --- a/code/datums/components/component.dm +++ b/code/datums/components/component.dm @@ -1,8 +1,8 @@ /datum/component - var/enabled = TRUE // Enables or disables the components - var/dupe_mode = COMPONENT_DUPE_HIGHLANDER // How components of the same type are handled in the same parent - var/list/signal_procs // list of signals -> callbacks - var/datum/parent // parent datum + var/enabled = TRUE + var/dupe_mode = COMPONENT_DUPE_HIGHLANDER + var/list/signal_procs + var/datum/parent /datum/component/New(datum/P, ...) var/dm = dupe_mode @@ -11,26 +11,78 @@ if(old) switch(dm) if(COMPONENT_DUPE_HIGHLANDER) - P.RemoveComponent(old) - old = null //in case SendSignal() blocks + InheritComponent(old, FALSE) + qdel(old) if(COMPONENT_DUPE_UNIQUE) + old.InheritComponent(src, TRUE) qdel(src) return - P.SendSignal(COMSIG_COMPONENT_ADDED, list(src), FALSE) - LAZYADD(P.datum_components, src) + P.SendSignal(COMSIG_COMPONENT_ADDED, src) + + //lazy init the parent's dc list + var/list/dc = P.datum_components + if(!dc) + P.datum_components = dc = list() + + //set up the typecache + var/our_type = type + for(var/I in _GetInverseTypeListExceptRoot(our_type)) + var/test = dc[I] + if(test) //already another component of this type here + var/list/components_of_type + if(!islist(test)) + components_of_type = list(test) + dc[I] = components_of_type + else + components_of_type = test + if(I == our_type) //exact match, take priority + var/inserted = FALSE + for(var/J in 1 to components_of_type.len) + var/datum/component/C = components_of_type[J] + if(C.type != our_type) //but not over other exact matches + components_of_type.Insert(J, I) + inserted = TRUE + break + if(!inserted) + components_of_type += src + else //indirect match, back of the line with ya + components_of_type += src + else //only component of this type, no list + dc[I] = src + parent = P /datum/component/Destroy() - RemoveNoSignal() - return ..() - -/datum/component/proc/RemoveNoSignal() + enabled = FALSE var/datum/P = parent if(P) - LAZYREMOVE(P.datum_components, src) + _RemoveNoSignal() + P.SendSignal(COMSIG_COMPONENT_REMOVING, src) + LAZYCLEARLIST(signal_procs) + return ..() + +/datum/component/proc/_RemoveNoSignal() + var/datum/P = parent + if(P) + var/list/dc = P.datum_components + var/our_type = type + for(var/I in _GetInverseTypeListExceptRoot(our_type)) + var/list/components_of_type = dc[I] + if(islist(components_of_type)) // + var/list/subtracted = components_of_type - src + if(subtracted.len == 1) //only 1 guy left + dc[I] = subtracted[1] //make him special + else + dc[I] = subtracted + else //just us + dc -= I + if(!dc.len) + P.datum_components = null parent = null /datum/component/proc/RegisterSignal(sig_type, proc_on_self, override = FALSE) + if(QDELETED(src)) + return var/list/procs = signal_procs if(!procs) procs = list() @@ -43,45 +95,71 @@ procs[sig_type] = CALLBACK(src, proc_on_self) -/datum/var/list/datum_components //list of /datum/component +/datum/component/proc/ReceiveSignal(sigtype, ...) + var/list/sps = signal_procs + var/datum/callback/CB = LAZYACCESS(sps, sigtype) + if(!CB) + return FALSE + var/list/arguments = args.Copy() + arguments.Cut(1, 2) + return CB.InvokeAsync(arglist(arguments)) -// Send a signal to all other components in the container. -/datum/proc/SendSignal(sigtype, list/sig_args, async = FALSE) +/datum/component/proc/InheritComponent(datum/component/C, i_am_original) + return + +/datum/component/proc/OnTransfer(datum/new_parent) + return + +/datum/component/proc/_GetInverseTypeListExceptRoot(our_type_cached) + var/datum/component/current_type = our_type_cached + . = list() + while (current_type != /datum/component) + . += current_type + current_type = type2parent(current_type) + +/datum/var/list/datum_components //special typecache of /datum/component + +/datum/proc/SendSignal(sigtype, ...) var/list/comps = datum_components . = FALSE for(var/I in comps) var/datum/component/C = I if(!C.enabled) continue - var/list/sps = C.signal_procs - var/datum/callback/CB = LAZYACCESS(sps, sigtype) - if(!CB) - continue - if(!async) - . |= CB.Invoke(sig_args) - else - . |= CB.InvokeAsync(sig_args) + if(C.ReceiveSignal(arglist(args))) + ComponentActivated(C) + . = TRUE + +/datum/proc/ComponentActivated(datum/component/C) + return /datum/proc/GetComponent(c_type) - for(var/I in datum_components) - if(istype(I, c_type)) - return I + var/list/dc = datum_components + if(!dc) + return null + . = dc[c_type] + if(islist(.)) + return .[1] /datum/proc/GetExactComponent(c_type) - for(var/I in datum_components) - var/datum/component/C = I + var/list/dc = datum_components + if(!dc) + return null + var/datum/component/C = dc[c_type] + if(C) + if(islist(C)) + C = C[1] if(C.type == c_type) - return I + return C + return null /datum/proc/GetComponents(c_type) - . = list() - for(var/I in datum_components) - if(istype(I, c_type)) - . += I - -/datum/proc/AddComponents(list/new_types) - for(var/new_type in new_types) - AddComponent(new_type) + var/list/dc = datum_components + if(!dc) + return null + . = dc[c_type] + if(!islist(.)) + return list(.) /datum/proc/AddComponent(new_type, ...) var/nt = new_type @@ -89,9 +167,15 @@ var/datum/component/C = new nt(arglist(args)) return QDELING(C) ? GetComponent(new_type) : C -/datum/proc/RemoveComponent(datum/component/C) +/datum/proc/TakeComponent(datum/component/C) if(!C) return - C.RemoveNoSignal() - SendSignal(COMSIG_COMPONENT_REMOVING, list(C), FALSE) - qdel(C) + var/datum/helicopter = C.parent + if(helicopter == src) + //wat + return + C._RemoveNoSignal() + helicopter.SendSignal(COMSIG_COMPONENT_REMOVING, C) + C.OnTransfer(src) + C.parent = src + SendSignal(COMSIG_COMPONENT_ADDED, C)