mirror of
https://github.com/ParadiseSS13/Paradise.git
synced 2026-08-22 11:37:40 +01:00
Refactors beams. Adds tethering. IV drips/bags are now tethered. (#29570)
* refactor * tether * tetherrrs * logic fix (i hope) * ci fix * ok please work
This commit is contained in:
Contrabang
+150
-80
@@ -1,91 +1,153 @@
|
||||
//Beam Datum and effect
|
||||
/** # Beam Datum and Effect
|
||||
* **IF YOU ARE LAZY AND DO NOT WANT TO READ, GO TO THE BOTTOM OF THE FILE AND USE THAT PROC!**
|
||||
*
|
||||
* This is the beam datum! It's a really neat effect for the game in drawing a line from one atom to another.
|
||||
* It has two parts:
|
||||
* The datum itself which manages redrawing the beam to constantly keep it pointing from the origin to the target.
|
||||
* The effect which is what the beams are made out of. They're placed in a line from the origin to target, rotated towards the target and snipped off at the end.
|
||||
* These effects are kept in a list and constantly created and destroyed (hence the proc names draw and reset, reset destroying all effects and draw creating more.)
|
||||
*
|
||||
* You can add more special effects to the beam itself by changing what the drawn beam effects do. For example you can make a vine that pricks people by making the beam_type
|
||||
* include a crossed proc that damages the crosser. Examples in venus_human_trap.dm
|
||||
*/
|
||||
/datum/beam
|
||||
///where the beam goes from
|
||||
var/atom/origin = null
|
||||
///where the beam goes to
|
||||
var/atom/target = null
|
||||
///list of beam objects. These have their visuals set by the visuals var which is created on starting
|
||||
var/list/elements = list()
|
||||
var/icon/base_icon = null
|
||||
///icon used by the beam.
|
||||
var/icon
|
||||
var/icon_state = "" //icon state of the main segments of the beam
|
||||
///icon state of the main segments of the beam
|
||||
var/icon_state = ""
|
||||
///The beam will qdel if it's longer than this many tiles.
|
||||
var/max_distance = 0
|
||||
var/endtime = 0
|
||||
var/sleep_time = 3
|
||||
var/finished = FALSE
|
||||
var/target_oldloc = null
|
||||
var/origin_oldloc = null
|
||||
var/static_beam = FALSE
|
||||
var/beam_type = /obj/effect/ebeam //must be subtype
|
||||
var/beamcolor
|
||||
///the objects placed in the elements list
|
||||
var/beam_type = /obj/effect/ebeam
|
||||
///This is used as the visual_contents of beams, so you can apply one effect to this and the whole beam will look like that. never gets deleted on redrawing.
|
||||
var/obj/effect/ebeam/visuals
|
||||
///The color of the beam we're drawing.
|
||||
var/beam_color
|
||||
///Should we use a turf for origin/target's x and y values instead
|
||||
var/use_get_turf
|
||||
|
||||
/datum/beam/New(beam_origin, beam_target,beam_icon = 'icons/effects/beam.dmi', beam_icon_state = "b_beam", time = 50, maxdistance = 10, btype = /obj/effect/ebeam, beam_sleep_time = 3, beam_color)
|
||||
endtime = world.time+time
|
||||
origin = beam_origin
|
||||
origin_oldloc = get_turf(origin)
|
||||
target = beam_target
|
||||
target_oldloc = get_turf(target)
|
||||
sleep_time = beam_sleep_time
|
||||
if(origin_oldloc == origin && target_oldloc == target)
|
||||
static_beam = TRUE
|
||||
max_distance = maxdistance
|
||||
base_icon = new(beam_icon,beam_icon_state)
|
||||
icon = beam_icon
|
||||
icon_state = beam_icon_state
|
||||
beam_type = btype
|
||||
beamcolor = beam_color
|
||||
/datum/beam/New(
|
||||
origin,
|
||||
target,
|
||||
icon = 'icons/effects/beam.dmi',
|
||||
icon_state = "b_beam",
|
||||
time = INFINITY,
|
||||
max_distance = INFINITY,
|
||||
beam_type = /obj/effect/ebeam,
|
||||
beam_color,
|
||||
use_get_turf = FALSE
|
||||
)
|
||||
src.origin = origin
|
||||
src.target = target
|
||||
src.icon = icon
|
||||
src.icon_state = icon_state
|
||||
src.max_distance = max_distance
|
||||
src.beam_type = beam_type
|
||||
src.beam_color = beam_color
|
||||
src.use_get_turf = use_get_turf
|
||||
if(time < INFINITY)
|
||||
QDEL_IN(src, time)
|
||||
|
||||
/**
|
||||
* Proc called by the atom Beam() proc. Sets up signals, and draws the beam for the first time.
|
||||
*/
|
||||
/datum/beam/proc/Start()
|
||||
visuals = new beam_type()
|
||||
visuals.icon = icon
|
||||
visuals.icon_state = icon_state
|
||||
visuals.color = beam_color
|
||||
visuals.vis_flags = VIS_INHERIT_PLANE|VIS_INHERIT_LAYER
|
||||
visuals.update_appearance()
|
||||
Draw()
|
||||
while(!finished && origin && target && world.time < endtime && get_dist(origin,target)<max_distance && origin.z == target.z)
|
||||
var/origin_turf = get_turf(origin)
|
||||
var/target_turf = get_turf(target)
|
||||
if(!static_beam && (origin_turf != origin_oldloc || target_turf != target_oldloc))
|
||||
origin_oldloc = origin_turf //so we don't keep checking against their initial positions, leading to endless Reset()+Draw() calls
|
||||
target_oldloc = target_turf
|
||||
Reset()
|
||||
Draw()
|
||||
sleep(sleep_time)
|
||||
RegisterSignal(origin, list(COMSIG_MOVABLE_MOVED, COMSIG_PARENT_QDELETING), PROC_REF(redrawing), TRUE)
|
||||
RegisterSignal(target, list(COMSIG_MOVABLE_MOVED, COMSIG_PARENT_QDELETING), PROC_REF(redrawing), TRUE)
|
||||
|
||||
qdel(src)
|
||||
|
||||
/datum/beam/proc/End()
|
||||
finished = TRUE
|
||||
|
||||
/datum/beam/proc/Reset()
|
||||
/**
|
||||
* Triggered by signals set up when the beam is set up. If it's still sane to create a beam, it removes the old beam, creates a new one. Otherwise it kills the beam.
|
||||
*
|
||||
* Arguments:
|
||||
* mover: either the origin of the beam or the target of the beam that moved.
|
||||
* oldloc: from where mover moved.
|
||||
* direction: in what direction mover moved from.
|
||||
*/
|
||||
/datum/beam/proc/redrawing(atom/movable/mover, atom/oldloc, direction)
|
||||
SIGNAL_HANDLER
|
||||
if(QDELING(src))
|
||||
return
|
||||
if(QDELETED(origin) || QDELETED(target) || get_dist(origin,target) > max_distance)
|
||||
qdel(src)
|
||||
return
|
||||
if(origin.z != target.z)
|
||||
if(!use_get_turf || !atoms_share_level(get_turf(origin), get_turf(target)))
|
||||
qdel(src)
|
||||
return
|
||||
QDEL_LIST_CONTENTS(elements)
|
||||
INVOKE_ASYNC(src, PROC_REF(Draw))
|
||||
|
||||
/datum/beam/Destroy()
|
||||
Reset()
|
||||
target = null
|
||||
QDEL_LIST_CONTENTS(elements)
|
||||
QDEL_NULL(visuals)
|
||||
UnregisterSignal(origin, list(COMSIG_MOVABLE_MOVED, COMSIG_PARENT_QDELETING))
|
||||
UnregisterSignal(target, list(COMSIG_MOVABLE_MOVED, COMSIG_PARENT_QDELETING))
|
||||
origin = null
|
||||
target = null
|
||||
return ..()
|
||||
|
||||
/**
|
||||
* Creates the beam effects and places them in a line from the origin to the target. Sets their rotation to make the beams face the target, too.
|
||||
*/
|
||||
/datum/beam/proc/Draw()
|
||||
var/Angle = round(get_angle(origin, target))
|
||||
var/origin_px = origin.pixel_x + origin.pixel_w
|
||||
var/origin_py = origin.pixel_y + origin.pixel_z
|
||||
var/target_px = target.pixel_x + target.pixel_w
|
||||
var/target_py = target.pixel_y + target.pixel_z
|
||||
|
||||
var/origin_x = origin.x
|
||||
var/origin_y = origin.y
|
||||
var/target_x = target.x
|
||||
var/target_y = target.y
|
||||
if(use_get_turf)
|
||||
var/turf/T = get_turf(origin)
|
||||
origin_x = T.x
|
||||
origin_y = T.y
|
||||
T = get_turf(target)
|
||||
target_x = T.x
|
||||
target_y = T.y
|
||||
|
||||
var/Angle = get_angle_raw(origin_x, origin_y, origin_px, origin_py, target_x, target_y, target_px, target_py)
|
||||
///var/Angle = round(get_angle(origin,target))
|
||||
var/matrix/rot_matrix = matrix()
|
||||
var/turf/origin_turf = get_turf(origin)
|
||||
rot_matrix.Turn(Angle)
|
||||
|
||||
//Translation vector for origin and target
|
||||
var/DX = (32*target.x+target.pixel_x)-(32*origin.x+origin.pixel_x)
|
||||
var/DY = (32*target.y+target.pixel_y)-(32*origin.y+origin.pixel_y)
|
||||
var/DX = (32 * target_x + target_px) - (32 * origin_x + origin_px)
|
||||
var/DY = (32 * target_y + target_py) - (32 * origin_y + origin_py)
|
||||
var/N = 0
|
||||
var/length = round(sqrt((DX)**2+(DY)**2)) //hypotenuse of the triangle formed by target and origin's displacement
|
||||
var/length = round(sqrt((DX)**2 + (DY)**2)) // hypotenuse of the triangle formed by target and origin's displacement
|
||||
|
||||
for(N in 0 to length-1 step 32)//-1 as we want < not <=, but we want the speed of X in Y to Z and step X
|
||||
var/obj/effect/ebeam/X = new beam_type(origin_oldloc)
|
||||
X.owner = src
|
||||
elements |= X
|
||||
for(N in 0 to length-1 step 32) // -1 as we want < not <=, but we want the speed of X in Y to Z and step X
|
||||
if(QDELETED(src))
|
||||
break
|
||||
var/obj/effect/ebeam/segment = new beam_type(origin_turf, src)
|
||||
elements += segment
|
||||
|
||||
//Assign icon, for main segments it's base_icon, for the end, it's icon+icon_state
|
||||
//cropped by a transparent box of length-N pixel size
|
||||
if(N+32>length)
|
||||
var/icon/II = new(icon, icon_state)
|
||||
II.DrawBox(null, 1, (length-N), 32, 32)
|
||||
X.icon = II
|
||||
//Assign our single visual ebeam to each ebeam's vis_contents
|
||||
//ends are cropped by a transparent box icon of length-N pixel size laid over the visuals obj
|
||||
if(N + 32 > length) //went past the target, we draw a box of space to cut away from the beam sprite so the icon actually ends at the center of the target sprite
|
||||
var/icon/II = new(icon, icon_state)//this means we exclude the overshooting object from the visual contents which does mean those visuals don't show up for the final bit of the beam...
|
||||
II.DrawBox(null, 1, (length-N), 32, 32)//in the future if you want to improve this, remove the drawbox and instead use a 513 filter to cut away at the final object's icon
|
||||
segment.icon = II
|
||||
segment.color = beam_color
|
||||
else
|
||||
X.icon = base_icon
|
||||
if(beamcolor)
|
||||
X.color = beamcolor
|
||||
X.transform = rot_matrix
|
||||
segment.vis_contents += visuals
|
||||
segment.transform = rot_matrix
|
||||
|
||||
//Calculate pixel offsets (If necessary)
|
||||
var/Pixel_x
|
||||
@@ -93,40 +155,44 @@
|
||||
if(DX == 0)
|
||||
Pixel_x = 0
|
||||
else
|
||||
Pixel_x = round(sin(Angle)+32*sin(Angle)*(N+16)/32)
|
||||
Pixel_x = round(sin(Angle) + 32 * sin(Angle) * (N + 16) / 32)
|
||||
if(DY == 0)
|
||||
Pixel_y = 0
|
||||
else
|
||||
Pixel_y = round(cos(Angle) + 32 * cos(Angle) * (N + 16) / 32)
|
||||
|
||||
//Position the effect so the beam is one continous line
|
||||
var/final_x = X.x
|
||||
var/final_y = X.y
|
||||
if(abs(Pixel_x)>32)
|
||||
final_x += Pixel_x > 0 ? round(Pixel_x / 32) : CEILING(Pixel_x / 32, 1)
|
||||
var/final_x = segment.x
|
||||
var/final_y = segment.y
|
||||
if(abs(Pixel_x) > 32)
|
||||
final_x += Pixel_x > 0 ? round(Pixel_x/32) : CEILING(Pixel_x/32, 1)
|
||||
Pixel_x %= 32
|
||||
if(abs(Pixel_y)>32)
|
||||
final_y += Pixel_y > 0 ? round(Pixel_y / 32) : CEILING(Pixel_y / 32, 1)
|
||||
if(abs(Pixel_y) > 32)
|
||||
final_y += Pixel_y > 0 ? round(Pixel_y/32) : CEILING(Pixel_y/32, 1)
|
||||
Pixel_y %= 32
|
||||
|
||||
var/turf/T = locate(final_x, final_y, X.z)
|
||||
if(T)
|
||||
X.forceMove(locate(final_x, final_y, X.z))
|
||||
X.pixel_x = origin.pixel_x + Pixel_x
|
||||
X.pixel_y = origin.pixel_y + Pixel_y
|
||||
segment.forceMove(locate(final_x, final_y, segment.z))
|
||||
segment.pixel_x = origin_px + Pixel_x
|
||||
segment.pixel_y = origin_py + Pixel_y
|
||||
CHECK_TICK
|
||||
|
||||
/obj/effect/ebeam
|
||||
mouse_opacity = MOUSE_OPACITY_TRANSPARENT
|
||||
anchored = TRUE
|
||||
var/datum/beam/owner
|
||||
|
||||
/obj/effect/ebeam/Initialize(mapload)
|
||||
/obj/effect/ebeam/Initialize(mapload, beam_owner)
|
||||
. = ..()
|
||||
owner = beam_owner
|
||||
var/static/list/loc_connections = list(
|
||||
COMSIG_ATOM_ENTERED = PROC_REF(on_atom_entered),
|
||||
)
|
||||
AddElement(/datum/element/connect_loc, loc_connections)
|
||||
|
||||
/obj/effect/ebeam/Destroy()
|
||||
owner = null
|
||||
return ..()
|
||||
|
||||
/obj/effect/ebeam/proc/on_atom_entered(datum/source, atom/movable/entered)
|
||||
SIGNAL_HANDLER // ON_ATOM_ENTERED
|
||||
return
|
||||
@@ -134,10 +200,6 @@
|
||||
/obj/effect/ebeam/ex_act(severity)
|
||||
return
|
||||
|
||||
/obj/effect/ebeam/Destroy()
|
||||
owner = null
|
||||
return ..()
|
||||
|
||||
/obj/effect/ebeam/singularity_pull()
|
||||
return
|
||||
|
||||
@@ -178,7 +240,15 @@
|
||||
var/armor = L.run_armor_check(limb_to_hit, LASER)
|
||||
L.apply_damage(damage, BURN, limb_to_hit, armor)
|
||||
|
||||
/atom/proc/Beam(atom/BeamTarget, icon_state="b_beam", icon='icons/effects/beam.dmi', time = 5 SECONDS, maxdistance = 10, beam_type = /obj/effect/ebeam, beam_sleep_time = 3, beam_color)
|
||||
var/datum/beam/newbeam = new(src, BeamTarget, icon, icon_state, time, maxdistance, beam_type, beam_sleep_time, beam_color)
|
||||
/atom/proc/Beam(atom/BeamTarget,
|
||||
icon_state = "b_beam",
|
||||
icon = 'icons/effects/beam.dmi',
|
||||
time = 5 SECONDS,
|
||||
maxdistance = 10,
|
||||
beam_type = /obj/effect/ebeam,
|
||||
beam_color,
|
||||
use_get_turf = FALSE
|
||||
)
|
||||
var/datum/beam/newbeam = new(src, BeamTarget, icon, icon_state, time, maxdistance, beam_type, beam_color, use_get_turf)
|
||||
INVOKE_ASYNC(newbeam, TYPE_PROC_REF(/datum/beam, Start))
|
||||
return newbeam
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
/datum/component/tether
|
||||
dupe_mode = COMPONENT_DUPE_ALLOWED
|
||||
var/atom/movable/tethered_to
|
||||
// Durability decreases with every on_range. Snaps when durability = 0.
|
||||
var/durability = INFINITY
|
||||
var/max_range = 2
|
||||
var/tether_icon_state
|
||||
|
||||
var/datum/movement_detector/tether_tracker
|
||||
var/datum/movement_detector/parent_tracker
|
||||
var/datum/beam/beam
|
||||
var/atom/movable/tether_visual_target
|
||||
var/tether_name
|
||||
var/last_movement = 0
|
||||
|
||||
/datum/component/tether/Initialize(tethered_atom_movable, range = 2, durability = INFINITY, tether_icon_state = "tether", tether_name = "tether")
|
||||
. = ..()
|
||||
if(!isatom(parent) || !ismovable(tethered_atom_movable))
|
||||
return COMPONENT_INCOMPATIBLE
|
||||
|
||||
src.tethered_to = tethered_atom_movable
|
||||
src.max_range = range
|
||||
src.durability = durability // movement is bugged right now. Durability wears out 3 times faster than expected. 1 durability should last 1 tile.
|
||||
src.tether_icon_state = tether_icon_state
|
||||
src.tether_name = tether_name
|
||||
|
||||
RegisterSignal(parent, COMSIG_MOVABLE_PRE_MOVE, PROC_REF(on_movement))
|
||||
RegisterSignal(tethered_atom_movable, COMSIG_MOVABLE_PRE_MOVE, PROC_REF(pre_tethered_movement))
|
||||
RegisterSignal(tethered_atom_movable, COMSIG_ATOM_ATTACK_HAND, PROC_REF(can_equip))
|
||||
parent_tracker = new /datum/movement_detector(parent, CALLBACK(src, PROC_REF(parent_check_bounds)))
|
||||
tether_tracker = new /datum/movement_detector(tethered_atom_movable, CALLBACK(src, PROC_REF(check_bounds)))
|
||||
parent_tracker.fix_signal()
|
||||
make_beam(tether_tracker.fix_signal() || tethered_to)
|
||||
|
||||
RegisterSignal(parent, COMSIG_PARENT_QDELETING, PROC_REF(terminate))
|
||||
RegisterSignal(tethered_atom_movable, list(COMSIG_PARENT_QDELETING, COMSIG_TETHER_STOP), PROC_REF(terminate))
|
||||
|
||||
if(get_dist(get_turf(parent), get_turf(tethered_to)) <= max_range)
|
||||
return
|
||||
tether_move_towards_parent()
|
||||
|
||||
/datum/component/tether/Destroy(force, silent)
|
||||
QDEL_NULL(tether_tracker)
|
||||
QDEL_NULL(parent_tracker)
|
||||
if(!QDELETED(beam))
|
||||
qdel(beam)
|
||||
beam = null
|
||||
SEND_SIGNAL(tethered_to, COMSIG_TETHER_DESTROYED)
|
||||
tether_visual_target = null
|
||||
tethered_to = null
|
||||
return ..()
|
||||
|
||||
/datum/component/tether/proc/make_beam(target)
|
||||
if(target == tether_visual_target)
|
||||
return
|
||||
tether_visual_target = target
|
||||
if(beam)
|
||||
UnregisterSignal(beam, COMSIG_PARENT_QDELETING)
|
||||
QDEL_NULL(beam)
|
||||
var/atom/atom = parent
|
||||
beam = atom.Beam(tether_visual_target, icon_state = tether_icon_state, time = INFINITY, use_get_turf = TRUE)
|
||||
RegisterSignal(beam, COMSIG_PARENT_QDELETING, PROC_REF(terminate))
|
||||
|
||||
// /datum/component/tether/proc/on_movement(atom/source, atom/oldloc, dir, forced)
|
||||
/datum/component/tether/proc/on_movement(atom/movable/source, newloc)
|
||||
// check if the item is in range. If not, try to move it towards the parent.
|
||||
if(get_dist(get_turf(tethered_to), newloc) <= max_range)
|
||||
return
|
||||
if(source.pulledby == tethered_to.loc)
|
||||
return
|
||||
if(tether_move_towards_parent(newloc))
|
||||
return
|
||||
if(get_dir(parent, newloc) & get_dir(parent, tethered_to))
|
||||
return
|
||||
var/atom/atom = parent
|
||||
atom?.setDir(get_dir(parent, newloc))
|
||||
to_chat(atom, "<span class='warning'>You can't move in that direction with the [tethered_to] tethered to you!</span>")
|
||||
return COMPONENT_MOVABLE_BLOCK_PRE_MOVE
|
||||
|
||||
/datum/component/tether/proc/pre_tethered_movement(atom/movable/source, newloc)
|
||||
// check if the item would be in range at its new tile. If not, return COMPONENT_MOVABLE_BLOCK_PRE_MOVE
|
||||
if(get_dist(get_turf(parent), newloc) <= max_range)
|
||||
return
|
||||
if(get_dir(tethered_to, newloc) & get_dir(tethered_to, parent))
|
||||
return
|
||||
durability_cost()
|
||||
var/atom/atom = parent
|
||||
atom?.setDir(get_dir(parent, newloc))
|
||||
to_chat(atom, "<span class='warning'>You can't move in that direction with the [tethered_to] tethered to you!</span>")
|
||||
return COMPONENT_MOVABLE_BLOCK_PRE_MOVE
|
||||
|
||||
/datum/component/tether/proc/can_equip(atom/source, mob/user)
|
||||
// Check to make sure we dont go into an inventory outside of our range
|
||||
if(get_dist(get_turf(parent), get_turf(user)) > max_range)
|
||||
to_chat(user, "<span class='warning'>You try to pick up [tethered_to], you can't pull it's [tether_name] any farther!</span>")
|
||||
return COMPONENT_CANCEL_ATTACK_CHAIN
|
||||
|
||||
/datum/component/tether/proc/parent_check_bounds(atom/movable/source, atom/mover, atom/old_loc, direction)
|
||||
// check to see if the parent has moved out of range (while inside another objects contents). If it has, pull the tether towards the parent.
|
||||
if(get_dist(get_turf(parent), get_turf(tethered_to)) <= max_range)
|
||||
return
|
||||
if(source.pulledby == tethered_to.loc)
|
||||
return
|
||||
tether_move_towards_parent()
|
||||
|
||||
/datum/component/tether/proc/check_bounds(atom/movable/source, atom/mover, atom/old_loc, direction)
|
||||
// check to see if the tethered object is out of range.
|
||||
// If it is, make it be dropped from a mob's hand, or open a locker its in.
|
||||
make_beam(mover)
|
||||
if(get_dist(get_turf(parent), get_turf(tethered_to)) <= max_range)
|
||||
return
|
||||
if(ismovable(mover))
|
||||
var/atom/movable/a_mover = mover
|
||||
if(a_mover.pulledby == parent || a_mover.pulling == parent)
|
||||
return
|
||||
tether_move_towards_parent()
|
||||
|
||||
/datum/component/tether/proc/tether_move_towards_parent(parent_newloc)
|
||||
if(QDELETED(tethered_to) || !istype(tethered_to) || last_movement == world.time)
|
||||
return TRUE
|
||||
var/atom/current_loc = tethered_to.loc
|
||||
var/i = 0
|
||||
while(!isturf(current_loc) && current_loc != null && current_loc != current_loc.loc)
|
||||
if(i++ > 100)
|
||||
return TRUE
|
||||
if(ismob(current_loc))
|
||||
var/mob/M = current_loc
|
||||
M.drop_item_to_ground(tethered_to)
|
||||
current_loc = tethered_to.loc
|
||||
break
|
||||
if(istype(current_loc, /obj/item/storage))
|
||||
var/obj/item/storage/S = current_loc
|
||||
S.remove_from_storage(tethered_to, get_turf(tethered_to))
|
||||
current_loc = tethered_to.loc
|
||||
break
|
||||
if(istype(current_loc, /obj/structure/closet))
|
||||
var/obj/structure/closet/C = current_loc
|
||||
if(C.can_open())
|
||||
C.open()
|
||||
current_loc = tethered_to.loc
|
||||
break
|
||||
if(ismovable(current_loc))
|
||||
var/atom/movable/AM = current_loc
|
||||
if(AM.anchored)
|
||||
return FALSE
|
||||
if(isturf(AM.loc))
|
||||
last_movement = world.time
|
||||
durability_cost()
|
||||
step_towards(AM, get_turf(parent)) // holy shitcode
|
||||
return get_dist(get_turf(parent_newloc || parent), get_turf(tethered_to)) <= max_range
|
||||
current_loc = current_loc.loc
|
||||
if(get_dist(get_turf(parent), get_turf(tethered_to)) <= max_range)
|
||||
return TRUE
|
||||
last_movement = world.time
|
||||
durability_cost()
|
||||
if(!step_towards(tethered_to, get_turf(parent))) // shitcode
|
||||
return durability_cost(2) // use 3 total durability
|
||||
return TRUE
|
||||
|
||||
/datum/component/tether/proc/terminate(source, force)
|
||||
if(QDELETED(src))
|
||||
return
|
||||
qdel(src)
|
||||
|
||||
/datum/component/tether/proc/durability_cost(cost = 1)
|
||||
if(durability == INFINITY)
|
||||
return
|
||||
durability -= cost
|
||||
if(durability <= 0 && !QDELETED(tethered_to))
|
||||
tethered_to.visible_message("<span class='warning'>[tethered_to]'s [tether_name] wears out and snaps back!</span>")
|
||||
terminate()
|
||||
return TRUE // it breaks, let the parent move outside of the range again
|
||||
return FALSE
|
||||
@@ -33,6 +33,24 @@
|
||||
UnregisterSignal(target, COMSIG_MOVABLE_MOVED)
|
||||
target = target.loc
|
||||
|
||||
|
||||
/**
|
||||
* Movement detectors don't work by default unless the item starts on a turf.
|
||||
* Run this proc to fix that.
|
||||
*/
|
||||
/datum/movement_detector/proc/fix_signal()
|
||||
// we're already inside something
|
||||
var/atom/current_target = tracked.loc
|
||||
var/turf/newturf = get_turf(tracked)
|
||||
var/i = 0
|
||||
while(current_target.loc != newturf && current_target != null)
|
||||
current_target = current_target.loc
|
||||
if(i++ <= 100)
|
||||
return
|
||||
if(ismovable(current_target))
|
||||
RegisterSignal(current_target, COMSIG_MOVABLE_MOVED, PROC_REF(move_react), TRUE)
|
||||
return current_target
|
||||
|
||||
/**
|
||||
* Reacts to any movement that would cause a change in coordinates of the tracked movable atom
|
||||
* This works by detecting movement of either the tracked object, or anything it is inside, recursively
|
||||
|
||||
Reference in New Issue
Block a user