anchor.diff:  	
   	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
  
positive.code: /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
  
  /datum/component/New(datum/P, ...)
  	var/dm = dupe_mode
  
negative.code: 	var/datum/component/C = new nt(arglist(args))
  	return QDELING(C) ? GetComponent(new_type) : C
  
  /datum/proc/TakeComponent(datum/component/C)
  	if(!C)
  		return
  	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)
  