wardrobe

Vars
cache_intensity	How much to cache outfit items Multiplier, 2 would mean cache enough items to stock 1 of each preloaded order twice, etc
canon_minimum	Canonical list of types required to fill all preloaded stocks once. Type -> list(count, last inspection timestamp, call on insert, call on removal)
current_task	What we're currently doing
initial_callbacks	List of type -> list(insertion callback, removal callback) callbacks for insertion/removal to use. Set in setup_callbacks, used in canonization.
inspect_delay	How often to inspect our stock, in deciseconds
last_inspect_time	The last time we inspected our stock
one_go_master	How many items would we make just by loading the master list once?
order_list	List of types to load. Type -> count //(I'd do a list of lists but this needs to be refillable)
overflow_lienency	How many more then the template of a type are we allowed to have before we delete applicants?
preloaded_stock	List of lists. Contains our preloaded atoms. Type -> list(last inspect time, list(instances))
recycle_blacklist	Item types that should not ever be recycled, only generated (like modsuits)
stock_hit	How many times we've successfully returned a cached item
stock_miss	How many times we've had to generate a stock item on request
Procs
canonize_type	Canonizes the type, which means it's now managed by the subsystem, and will be created deleted and passed out to comsumers
force_stock_wardrobe	Stocks the wardrobe to stock_to items, no more no less Only usable for testing, will not work well in production as it'll likely just get run over by other code
get_callback_type	Takes a path to get the callback owner for Returns the deepest path in our callback store that matches the input The hope is this will prevent dumb conflicts, since the furthest down is always going to be the most relevant
hard_refresh_queue	Resets the load queue to the master template, accounting for the existing stock
recycle_object	Take an existing object, and recycle it if we are allowed to by stashing it back into our storage
run_inspection	Once every medium while, go through the current stock and make sure we don't have too much of one thing Or that we're not too low on some other stock This exists as a failsafe, so the wardrobe doesn't just end up generating too many items or accidentially running out somehow
setup_callbacks	Sets up insertion and removal callbacks by typepath We will always use the deepest path. So /obj/item/blade/knife superceeds the entries of /obj/item and /obj/item/blade Mind this
speed_test	Runs a speed test for all our various types Measures the average cost of providing vs spawning, and deletion vs stashing
stash_object	Take an existing object, and tries to insert it into our storage Returns TRUE if we've taken it (you no longer own it), FALSE if we have not
stock_wardrobe	Turns the order list into actual loaded items, this is where most work is done
unload_stock	Unloads an amount of some type we have in stock Private function, for internal use only
yield_object	Yields an object to the wardrobe subsystem, you no longer own it after calling this proc

Var Details

var
cache_intensity

How much to cache outfit items Multiplier, 2 would mean cache enough items to stock 1 of each preloaded order twice, etc

var
canon_minimum
– /list

Canonical list of types required to fill all preloaded stocks once. Type -> list(count, last inspection timestamp, call on insert, call on removal)

var
current_task

What we're currently doing

var
initial_callbacks
– /list

List of type -> list(insertion callback, removal callback) callbacks for insertion/removal to use. Set in setup_callbacks, used in canonization.

var
inspect_delay

How often to inspect our stock, in deciseconds

var
last_inspect_time

The last time we inspected our stock

var
one_go_master

How many items would we make just by loading the master list once?

var
order_list
– /list

List of types to load. Type -> count //(I'd do a list of lists but this needs to be refillable)

var
overflow_lienency

How many more then the template of a type are we allowed to have before we delete applicants?

var
preloaded_stock
– /list

List of lists. Contains our preloaded atoms. Type -> list(last inspect time, list(instances))

var
recycle_blacklist
– /static/list

Item types that should not ever be recycled, only generated (like modsuits)

var
stock_hit

How many times we've successfully returned a cached item

var
stock_miss

How many times we've had to generate a stock item on request

Proc Details

proc
canonize_type
(type_to_stock, amount)

Canonizes the type, which means it's now managed by the subsystem, and will be created deleted and passed out to comsumers

Arguments:

type to stock - What type exactly do you want us to remember?

proc
force_stock_wardrobe
(stock_to)

Stocks the wardrobe to stock_to items, no more no less Only usable for testing, will not work well in production as it'll likely just get run over by other code

proc
get_callback_type
(/datum/to_check)

Takes a path to get the callback owner for Returns the deepest path in our callback store that matches the input The hope is this will prevent dumb conflicts, since the furthest down is always going to be the most relevant

proc
hard_refresh_queue
()

Resets the load queue to the master template, accounting for the existing stock

proc
recycle_object
(/obj/item/object)

Take an existing object, and recycle it if we are allowed to by stashing it back into our storage

proc
run_inspection
()

Once every medium while, go through the current stock and make sure we don't have too much of one thing Or that we're not too low on some other stock This exists as a failsafe, so the wardrobe doesn't just end up generating too many items or accidentially running out somehow

proc
setup_callbacks
()

Sets up insertion and removal callbacks by typepath We will always use the deepest path. So /obj/item/blade/knife superceeds the entries of /obj/item and /obj/item/blade Mind this

proc
speed_test
(/turf/spawn_on, attempt_count)

Runs a speed test for all our various types Measures the average cost of providing vs spawning, and deletion vs stashing

proc
stash_object
(/obj/item/object)

Take an existing object, and tries to insert it into our storage Returns TRUE if we've taken it (you no longer own it), FALSE if we have not

proc
stock_wardrobe
()

Turns the order list into actual loaded items, this is where most work is done

proc
unload_stock
(/datum/unload_type, amount, force)

Unloads an amount of some type we have in stock Private function, for internal use only

proc
yield_object
(/obj/item/object)

Yields an object to the wardrobe subsystem, you no longer own it after calling this proc

wardrobe /datum/controller/subsystem/wardrobe

Vars

Procs

Var Details

var cache_intensity

var canon_minimum – /list

var current_task

var initial_callbacks – /list

var inspect_delay

var last_inspect_time

var one_go_master

var order_list – /list

var overflow_lienency

var preloaded_stock – /list

var recycle_blacklist – /static/list

var stock_hit

var stock_miss

Proc Details

proc canonize_type(type_to_stock, amount)

proc force_stock_wardrobe(stock_to)

proc get_callback_type(/datum/to_check)

proc hard_refresh_queue()

proc recycle_object(/obj/item/object)

proc run_inspection()

proc setup_callbacks()

proc speed_test(/turf/spawn_on, attempt_count)

proc stash_object(/obj/item/object)

proc stock_wardrobe()

proc unload_stock(/datum/unload_type, amount, force)

proc yield_object(/obj/item/object)