mirror of
https://github.com/ParadiseSS13/Paradise.git
synced 2026-08-17 00:57:28 +01:00
warriorstar-orionandGitHub
525c68d617
* refactor: Attack chain, initial setup. * migrate curtain to make dreamchecker happy * update thurible * don't call attacked_by separately for legacy attack chain * remove duplicate proc * condense similar code, put allowances for legacy code in new procs * update docs, include diagram source * add comment on how to update diagram * fix admonition * mindflayer updates * remove commented out code * clarify all steps * after_attack should be overridable * whoops * retrofit recent changes * duh, can't restrict this yet because of tool_acts * i hate ore bags with the fire of a thousand suns * return correct value for object attack logic * Various cleanups. We don't want to attempt to pull stuff out of `/obj/item/attackby`, because those pieces are part of the related objects' migrations, not `/obj/item` itself. Attempting to do this causes knockon effects where things expected to call e.g. `/obj/item/storage/attackby` in the call chain were not ferried over to the new item interaction code, because the related objects hadn't actually been migrated over yet. I've used refactoring /obj/vehicle as the example for migrating `attackby` methods instead. * simplify some argument names * fuck it * make it do the thing * Rename CI module call * Prove that CI works * improve test output * aaand fix it again * fix curtain tool interactions * fix compile error * fix compile error * Better docs, introduce migration plan tool.
89 lines
3.4 KiB
Plaintext
89 lines
3.4 KiB
Plaintext
//A storage item intended to be used by other items to provide storage functionality.
|
|
//Types that use this should consider overriding emp_act() and hear_talk(), unless they shield their contents somehow.
|
|
/obj/item/storage/internal
|
|
var/obj/item/master_item
|
|
|
|
/obj/item/storage/internal/New(obj/item/MI)
|
|
master_item = MI
|
|
loc = master_item
|
|
name = master_item.name
|
|
..()
|
|
|
|
/obj/item/storage/internal/Destroy()
|
|
master_item = null
|
|
return ..()
|
|
|
|
/obj/item/storage/internal/attack_hand()
|
|
return //make sure this is never picked up
|
|
|
|
/obj/item/storage/internal/mob_can_equip(mob/M, slot, disable_warning = FALSE)
|
|
return 0 //make sure this is never picked up
|
|
|
|
//Helper procs to cleanly implement internal storages - storage items that provide inventory slots for other items.
|
|
//These procs are completely optional, it is up to the master item to decide when it's storage get's opened by calling open()
|
|
//However they are helpful for allowing the master item to pretend it is a storage item itself.
|
|
//If you are using these you will probably want to override attackby__legacy__attackchain() as well.
|
|
//See /obj/item/clothing/suit/storage for an example.
|
|
|
|
//items that use internal storage have the option of calling this to emulate default storage MouseDrop behaviour.
|
|
//returns 1 if the master item's parent's MouseDrop() should be called, 0 otherwise. It's strange, but no other way of
|
|
//doing it without the ability to call another proc's parent, really.
|
|
/obj/item/storage/internal/proc/handle_mousedrop(mob/user as mob, obj/over_object as obj)
|
|
if(ishuman(user)) //so monkeys can take off their backpacks -- Urist
|
|
|
|
if(ismecha(user.loc)) // stops inventory actions in a mech
|
|
return 0
|
|
|
|
if(over_object == user && Adjacent(user)) // this must come before the screen objects only block
|
|
open(user)
|
|
return FALSE
|
|
|
|
if(!is_screen_atom(over_object))
|
|
return TRUE
|
|
|
|
//makes sure master_item is equipped before putting it in hand, so that we can't drag it into our hand from miles away.
|
|
//there's got to be a better way of doing this...
|
|
if(!(master_item.loc == user) || (master_item.loc && master_item.loc.loc == user))
|
|
return 0
|
|
|
|
if(!user.restrained() && !user.stat)
|
|
switch(over_object.name)
|
|
if("r_hand")
|
|
user.unEquip(master_item, silent = TRUE)
|
|
user.put_in_r_hand(master_item)
|
|
if("l_hand")
|
|
user.unEquip(master_item, silent = TRUE)
|
|
user.put_in_l_hand(master_item)
|
|
master_item.add_fingerprint(user)
|
|
return 0
|
|
return 0
|
|
|
|
//items that use internal storage have the option of calling this to emulate default storage attack_hand behaviour.
|
|
//returns 1 if the master item's parent's attack_hand() should be called, 0 otherwise.
|
|
//It's strange, but no other way of doing it without the ability to call another proc's parent, really.
|
|
/obj/item/storage/internal/proc/handle_attack_hand(mob/user as mob)
|
|
|
|
if(ishuman(user))
|
|
var/mob/living/carbon/human/H = user
|
|
if(H.l_store == master_item && !H.get_active_hand()) //Prevents opening if it's in a pocket.
|
|
H.put_in_hands(master_item)
|
|
H.l_store = null
|
|
return 0
|
|
if(H.r_store == master_item && !H.get_active_hand())
|
|
H.put_in_hands(master_item)
|
|
H.r_store = null
|
|
return 0
|
|
|
|
add_fingerprint(user)
|
|
if(master_item.loc == user)
|
|
open(user)
|
|
return 0
|
|
|
|
for(var/mob/M in range(1, master_item.loc))
|
|
if(M.s_active == src)
|
|
close(M)
|
|
return 1
|
|
|
|
/obj/item/storage/internal/Adjacent(atom/neighbor)
|
|
return master_item.Adjacent(neighbor)
|