///////////////////////////////

//CABLE STRUCTURE

///////////////////////////////

////////////////////////////////

// Definitions

////////////////////////////////

/* Cable directions (d1 and d2)

9 1 5

\ | /

8 - 0 - 4

/ | \

10 2 6

If d1 = 0 and d2 = 0, there's no cable

If d1 = 0 and d2 = dir, it's a O-X cable, getting from the center of the tile to dir (knot cable)

If d1 = dir1 and d2 = dir2, it's a full X-X cable, getting from dir1 to dir2

By design, d1 is the smallest direction and d2 is the highest

*/

/obj/structure/cable

name = "power cable"

desc = "A flexible, superconducting insulated cable for heavy-duty power transfer."

icon = 'icons/obj/power_cond/cables.dmi'

icon_state = "0-1"

///Yogs, Biome wanted cables above pipes

//plane = FLOOR_PLANE

layer = WIRE_LAYER //Above hidden pipes, GAS_PIPE_HIDDEN_LAYER

anchored = TRUE

obj_flags = CAN_BE_HIT | ON_BLUEPRINTS

var/d1 = 0 // cable direction 1 (see above)

var/d2 = 1 // cable direction 2 (see above)

var/datum/powernet/powernet

//Cables no longer keep a copy of the cable to be dropped in nullspace

var/cable_color = "red"

color = "#ff0000"

FASTDMM_PROP(\

pipe_type = PIPE_TYPE_CABLE,\

pipe_interference_group = list("cable"),\

pipe_group = "cable-[cable_color]"\

)

var/image/wire_vision_img //specifically for wirecrawling

/obj/structure/cable/yellow

cable_color = "yellow"

color = "#ffff00"

/obj/structure/cable/green

cable_color = "green"

color = "#00aa00"

/obj/structure/cable/blue

cable_color = "blue"

color = "#1919c8"

/obj/structure/cable/pink

cable_color = "pink"

color = "#ff3cc8"

/obj/structure/cable/orange

cable_color = "orange"

color = "#ff8000"

/obj/structure/cable/cyan

cable_color = "cyan"

color = "#00ffff"

/obj/structure/cable/white

cable_color = "white"

color = "#ffffff"

// the power cable object

/obj/structure/cable/Initialize(mapload, param_color)

. = ..()

// ensure d1 & d2 reflect the icon_state for entering and exiting cable

var/dash = findtext(icon_state, "-")

d1 = text2num( copytext( icon_state, 1, dash ) )

d2 = text2num( copytext( icon_state, dash+1 ) )

AddElement(/datum/element/undertile, TRAIT_T_RAY_VISIBLE)

GLOB.cable_list += src //add it to the global cable list

var/list/cable_colors = GLOB.cable_colors

cable_color = param_color || cable_color || pick(cable_colors)

if(cable_colors[cable_color])

cable_color = cable_colors[cable_color]

return INITIALIZE_HINT_LATELOAD

/obj/structure/cable/LateInitialize()

update_appearance(UPDATE_ICON)

//is_fully_initialized = TRUE

/obj/structure/cable/Destroy() // called when a cable is deleted

if(powernet)

cut_cable_from_powernet() // update the powernets

GLOB.cable_list -= src //remove it from global cable list

if(wire_vision_img)

qdel(wire_vision_img)

return ..() // then go ahead and delete the cable

/obj/structure/cable/deconstruct(disassembled = TRUE)

if(!(flags_1 & NODECONSTRUCT_1))

var/turf/T = loc

var/cableNum = 1

if (d1*d2 > 0) //this be true if the cable has two directions, aka it contains two cables. If there is only one cable, one out of d1 and d2 will be zero

cableNum = 2

var/newCables = new /obj/item/stack/cable_coil(T, cableNum, cable_color)

TransferComponents(newCables) //this copies the fingerprints over to the new object

qdel(src)

///////////////////////////////////

// General procedures

///////////////////////////////////

/obj/structure/cable/update_icon(updates=ALL)

. = ..()

icon_state = "[d1]-[d2]"

color = null

add_atom_colour(cable_color, FIXED_COLOUR_PRIORITY)

/obj/structure/cable/proc/handlecable(obj/item/W, mob/user, params)

var/turf/T = get_turf(src)

if(T.underfloor_accessibility < UNDERFLOOR_INTERACTABLE)

return

if(W.tool_behaviour == TOOL_WIRECUTTER)

if (shock(user, 50))

return

user.visible_message("[user] cuts the cable.", span_notice("You cut the cable."))

investigate_log("was cut by [key_name(usr)] in [AREACOORD(src)]", INVESTIGATE_WIRES)

add_fingerprint(user)

deconstruct()

return

else if(istype(W, /obj/item/stack/cable_coil))

var/obj/item/stack/cable_coil/coil = W

if (coil.get_amount() < 1)

to_chat(user, span_warning("Not enough cable!"))

return

coil.cable_join(src, user)

else if(istype(W, /obj/item/rcl))

var/obj/item/rcl/R = W

if(R.loaded)

R.loaded.cable_join(src, user)

R.is_empty(user)

else if(W.tool_behaviour == TOOL_MULTITOOL)

var/list/combined_msg = list()

if(powernet && (powernet.avail > 0)) // is it powered?

combined_msg += span_danger("Total power: [DisplayPower(powernet.avail)]\nLoad: [DisplayPower(powernet.load)]\nExcess power: [DisplayPower(surplus())]")

else

combined_msg += span_danger("The cable is not powered.")

shock(user, 5, 0.2)

to_chat(user, examine_block(combined_msg.Join("\n")))

add_fingerprint(user)

// Items usable on a cable :

// - Wirecutters : cut it duh !

// - Cable coil : merge cables

// - Multitool : get the power currently passing through the cable

//

/obj/structure/cable/attackby(obj/item/W, mob/user, params)

handlecable(W, user, params)

// shock the user with probability prb

/obj/structure/cable/proc/shock(mob/user, prb, siemens_coeff = 1)

if(!prob(prb))

return 0

if (electrocute_mob(user, powernet, src, siemens_coeff))

do_sparks(5, TRUE, src)

return 1

else

return 0

/obj/structure/cable/singularity_pull(S, current_size)

..()

if(current_size >= STAGE_FIVE)

deconstruct()

////////////////////////////////////////////

// Power related

///////////////////////////////////////////

// All power generation handled in add_avail()

// Machines should use add_load(), surplus(), avail()

// Non-machines should use add_delayedload(), delayed_surplus(), newavail()

/obj/structure/cable/proc/add_avail(amount)

if(powernet)

powernet.newavail += amount

/obj/structure/cable/proc/add_load(amount)

if(powernet)

powernet.load += amount

/obj/structure/cable/proc/surplus()

if(powernet)

return clamp(powernet.avail-powernet.load, 0, powernet.avail)

else

return 0

/obj/structure/cable/proc/avail()

if(powernet)

return powernet.avail

else

return 0

/obj/structure/cable/proc/add_delayedload(amount)

if(powernet)

powernet.delayedload += amount

/obj/structure/cable/proc/delayed_surplus()

if(powernet)

return clamp(powernet.newavail - powernet.delayedload, 0, powernet.newavail)

else

return 0

/obj/structure/cable/proc/newavail()

if(powernet)

return powernet.newavail

else

return 0

/////////////////////////////////////////////////

// Cable laying helpers

////////////////////////////////////////////////

//handles merging diagonally matching cables

//for info : direction^3 is flipping horizontally, direction^12 is flipping vertically

/obj/structure/cable/proc/mergeDiagonalsNetworks(direction)

//search for and merge diagonally matching cables from the first direction component (north/south)

var/turf/T = get_step(src, direction&3)//go north/south

for(var/obj/structure/cable/C in T)

if(!C)

continue

if(src == C)

continue

if(C.d1 == (direction^3) || C.d2 == (direction^3)) //we've got a diagonally matching cable

if(!C.powernet) //if the matching cable somehow got no powernet, make him one (should not happen for cables)

var/datum/powernet/newPN = new(C.loc.z)

newPN.add_cable(C)

if(powernet) //if we already have a powernet, then merge the two powernets

merge_powernets(powernet,C.powernet)

else

C.powernet.add_cable(src) //else, we simply connect to the matching cable powernet

//the same from the second direction component (east/west)

T = get_step(src, direction&12)//go east/west

for(var/obj/structure/cable/C in T)

if(!C)

continue

if(src == C)

continue

if(C.d1 == (direction^12) || C.d2 == (direction^12)) //we've got a diagonally matching cable

if(!C.powernet) //if the matching cable somehow got no powernet, make him one (should not happen for cables)

var/datum/powernet/newPN = new(C.loc.z)

newPN.add_cable(C)

if(powernet) //if we already have a powernet, then merge the two powernets

merge_powernets(powernet,C.powernet)

else

C.powernet.add_cable(src) //else, we simply connect to the matching cable powernet

// merge with the powernets of power objects in the given direction

/obj/structure/cable/proc/mergeConnectedNetworks(direction)

var/fdir = (!direction)? 0 : turn(direction, 180) //flip the direction, to match with the source position on its turf

if(!(d1 == direction || d2 == direction)) //if the cable is not pointed in this direction, do nothing

return

var/turf/TB = get_step(src, direction)

for(var/obj/structure/cable/C in TB)

if(!C)

continue

if(src == C)

continue

if(C.d1 == fdir || C.d2 == fdir) //we've got a matching cable in the neighbor turf

if(!C.powernet) //if the matching cable somehow got no powernet, make him one (should not happen for cables)

var/datum/powernet/newPN = new(C.loc.z)

newPN.add_cable(C)

if(powernet) //if we already have a powernet, then merge the two powernets

merge_powernets(powernet,C.powernet)

else

C.powernet.add_cable(src) //else, we simply connect to the matching cable powernet

// merge with the powernets of power objects in the source turf

/obj/structure/cable/proc/mergeConnectedNetworksOnTurf()

var/list/to_connect = list()

if(!powernet) //if we somehow have no powernet, make one (should not happen for cables)

var/datum/powernet/newPN = new(loc.z)

newPN.add_cable(src)

//first let's add turf cables to our powernet

//then we'll connect machines on turf with a node cable is present

for(var/AM in loc)

if(istype(AM, /obj/structure/cable))

var/obj/structure/cable/C = AM

if(C.d1 == d1 || C.d2 == d1 || C.d1 == d2 || C.d2 == d2) //only connected if they have a common direction

if(C.powernet == powernet)

continue

if(C.powernet)

merge_powernets(powernet, C.powernet)

else

powernet.add_cable(C) //the cable was powernetless, let's just add it to our powernet

else if(istype(AM, /obj/machinery/power/apc))

var/obj/machinery/power/apc/N = AM

if(!N.terminal)

continue // APC are connected through their terminal

if(N.terminal.powernet == powernet)

continue

to_connect += N.terminal //we'll connect the machines after all cables are merged

else if(istype(AM, /obj/machinery/power)) //other power machines

var/obj/machinery/power/M = AM

if(M.powernet == powernet)

continue

to_connect += M //we'll connect the machines after all cables are merged

//now that cables are done, let's connect found machines

for(var/obj/machinery/power/PM in to_connect)

if(!PM.connect_to_network())

PM.disconnect_from_network() //if we somehow can't connect the machine to the new powernet, remove it from the old nonetheless

//////////////////////////////////////////////

// Powernets handling helpers

//////////////////////////////////////////////

//if powernetless_only = 1, will only get connections without powernet

/obj/structure/cable/proc/get_connections(powernetless_only = 0)

. = list() // this will be a list of all connected power objects

var/turf/T

//get matching cables from the first direction

if(d1) //if not a node cable

T = get_step(src, d1)

if(T)

. += power_list(T, src, turn(d1, 180), powernetless_only) //get adjacents matching cables

if(d1&(d1-1)) //diagonal direction, must check the 4 possibles adjacents tiles

T = get_step(src,d1&3) // go north/south

if(T)

. += power_list(T, src, d1 ^ 3, powernetless_only) //get diagonally matching cables

T = get_step(src,d1&12) // go east/west

if(T)

. += power_list(T, src, d1 ^ 12, powernetless_only) //get diagonally matching cables

. += power_list(loc, src, d1, powernetless_only) //get on turf matching cables

//do the same on the second direction (which can't be 0)

T = get_step(src, d2)

if(T)

. += power_list(T, src, turn(d2, 180), powernetless_only) //get adjacents matching cables

if(d2&(d2-1)) //diagonal direction, must check the 4 possibles adjacents tiles

T = get_step(src,d2&3) // go north/south

if(T)

. += power_list(T, src, d2 ^ 3, powernetless_only) //get diagonally matching cables

T = get_step(src,d2&12) // go east/west

if(T)

. += power_list(T, src, d2 ^ 12, powernetless_only) //get diagonally matching cables

. += power_list(loc, src, d2, powernetless_only) //get on turf matching cables

return .

//should be called after placing a cable which extends another cable, creating a "smooth" cable that no longer terminates in the centre of a turf.

//needed as this can, unlike other placements, disconnect cables

/obj/structure/cable/proc/denode()

var/turf/T1 = loc

if(!T1)

return

var/list/powerlist = power_list(T1,src,0,0) //find the other cables that ended in the centre of the turf, with or without a powernet

if(powerlist.len>0)

var/datum/powernet/PN = new(loc.z)

propagate_network(powerlist[1],PN) //propagates the new powernet beginning at the source cable

if(PN.is_empty()) //can happen with machines made nodeless when smoothing cables

qdel(PN)

/obj/structure/cable/proc/auto_propogate_cut_cable(obj/O)

if(O && !QDELETED(O))

var/datum/powernet/newPN = new(loc.z)// creates a new powernet...

propagate_network(O, newPN)//... and propagates it to the other side of the cable

// cut the cable's powernet at this cable and updates the powergrid

/obj/structure/cable/proc/cut_cable_from_powernet(remove=TRUE)

var/turf/T1 = loc

var/list/P_list

if(!T1)

return

if(d1)

T1 = get_step(T1, d1)

P_list = power_list(T1, src, turn(d1,180),0,cable_only = 1) // what adjacently joins on to cut cable...

P_list += power_list(loc, src, d1, 0, cable_only = 1)//... and on turf

if(P_list.len == 0)//if nothing in both list, then the cable was a lone cable, just delete it and its powernet

powernet.remove_cable(src)

for(var/obj/machinery/power/P in T1)//check if it was powering a machine

if(!P.connect_to_network()) //can't find a node cable on a the turf to connect to

P.disconnect_from_network() //remove from current network (and delete powernet)

return

var/obj/O = P_list[1]

// remove the cut cable from its turf and powernet, so that it doesn't get count in propagate_network worklist

if(remove)

moveToNullspace()

powernet.remove_cable(src) //remove the cut cable from its powernet

addtimer(CALLBACK(O, PROC_REF(auto_propogate_cut_cable), O), 0) //so we don't rebuild the network X times when singulo/explosion destroys a line of X cables

// Disconnect machines connected to nodes

if(d1 == 0) // if we cut a node (O-X) cable

for(var/obj/machinery/power/P in T1)

if(!P.connect_to_network()) //can't find a node cable on a the turf to connect to

P.disconnect_from_network() //remove from current network

///////////////////////////////////////////////

// The cable coil object, used for laying cable

///////////////////////////////////////////////

////////////////////////////////

// Definitions

////////////////////////////////

#define CABLE_RESTRAINTS_COST 15

/obj/item/stack/cable_coil

name = "cable coil"

custom_price = 15

gender = NEUTER //That's a cable coil sounds better than that's some cable coils

icon = 'icons/obj/stack_objects.dmi'

icon_state = "coil"

item_state = "coil"

lefthand_file = 'icons/mob/inhands/equipment/tools_lefthand.dmi'

righthand_file = 'icons/mob/inhands/equipment/tools_righthand.dmi'

max_amount = MAXCOIL

amount = MAXCOIL

tool_behaviour = TOOL_WIRING

merge_type = /obj/item/stack/cable_coil // This is here to let its children merge between themselves

color = CABLE_HEX_COLOR_YELLOW

desc = "A coil of insulated power cable."

throwforce = 0

w_class = WEIGHT_CLASS_SMALL

throw_speed = 3

throw_range = 5

materials = list(/datum/material/iron=10, /datum/material/glass=5)

flags_1 = CONDUCT_1

slot_flags = ITEM_SLOT_BELT

attack_verb = list("whipped", "lashed", "disciplined", "flogged")

singular_name = "cable piece"

full_w_class = WEIGHT_CLASS_SMALL

grind_results = list(/datum/reagent/copper = 2) //2 copper per cable in the coil

usesound = 'sound/items/deconstruct.ogg'

var/cable_color = CABLE_COLOR_YELLOW

/obj/item/stack/cable_coil/Initialize(mapload, new_amount, param_color)

. = ..()

set_cable_color(param_color || cable_color)

pixel_x = rand(-2,2)

pixel_y = rand(-2,2)

update_appearance()

/obj/item/stack/cable_coil/proc/set_cable_color(new_color)

color = GLOB.cable_colors[new_color]

cable_color = new_color

update_appearance(UPDATE_ICON)

/obj/item/stack/cable_coil/suicide_act(mob/user)

if(locate(/obj/structure/chair/stool) in get_turf(user))

user.visible_message(span_suicide("[user] is making a noose with [src]! It looks like [user.p_theyre()] trying to commit suicide!"))

else

user.visible_message(span_suicide("[user] is strangling [user.p_them()]self with [src]! It looks like [user.p_theyre()] trying to commit suicide!"))

return(OXYLOSS)

/obj/item/stack/cable_coil/proc/check_menu(mob/living/user)

if(!istype(user))

return FALSE

if(!user.IsAdvancedToolUser())

to_chat(user, span_warning("You don't have the dexterity to do this!"))

return FALSE

if(user.incapacitated() || !user.Adjacent(src))

return FALSE

return TRUE

/obj/item/stack/cable_coil/attack_self(mob/living/user)

if(!user)

return

var/image/restraints_icon = image(icon = 'icons/obj/handcuffs.dmi', icon_state = "zipties")

restraints_icon.maptext = MAPTEXT("<span [amount >= CABLE_RESTRAINTS_COST ? "" : "style='color: red'"]>[CABLE_RESTRAINTS_COST]</span>")

restraints_icon.color = color

var/list/radial_menu = list(

"Multi-deck power adapter" = image(icon = 'icons/obj/power.dmi', icon_state = "cablerelay-broken-cable"),

"Cable restraints" = restraints_icon

)

var/layer_result = show_radial_menu(user, src, radial_menu, custom_check = CALLBACK(src, PROC_REF(check_menu), user), require_near = TRUE, tooltips = TRUE)

if(!check_menu(user))

return

switch(layer_result)

if("Cable restraints")

if (amount >= CABLE_RESTRAINTS_COST)

if(use(CABLE_RESTRAINTS_COST))

var/obj/item/restraints/handcuffs/cable/restraints = new(null, cable_color)

user.put_in_hands(restraints)

if("Multi-deck power adapter")

if(locate(/obj/machinery/power/deck_relay) in user.loc)

to_chat(user, span_danger("You can't place another relay here!"))

return

if(use(1))

new /obj/machinery/power/deck_relay(user.loc)

user.visible_message("[user] constructs a deck relay.")

update_appearance()

///////////////////////////////////

// General procedures

///////////////////////////////////

//you can use wires to heal robotics

/obj/item/stack/cable_coil/attack(mob/living/carbon/human/H, mob/user)

if(!istype(H))

return ..()

var/obj/item/bodypart/affecting = H.get_bodypart(check_zone(user.zone_selected))

if(affecting.burn_dam <= 0)

to_chat(user, span_warning("[affecting] is already in good condition!"))

return FALSE

if(affecting && affecting.status == BODYPART_ROBOTIC)

if(DOING_INTERACTION(user, H))

return FALSE

user.visible_message(span_notice("[user] starts to fix some of the wires in [H]'s [affecting.name]."), span_notice("You start fixing some of the wires in [H == user ? "your" : "[H]'s"] [affecting.name]."))

heal_robo_limb(src, H, user, 0, 10, 1)

user.visible_message(span_notice("[user] fixes the wires in [H]'s [affecting.name]."), span_notice("You fix the wires in [H == user ? "your" : "[H]'s"] [affecting.name]."))

return

return ..()

/obj/item/stack/cable_coil/update_icon_state()

. = ..()

if(!novariants)

return

icon_state = "[initial(item_state)][amount < 3 ? amount : ""]"

item_state = "coil_[cable_color]"

color = null

add_atom_colour(cable_color, FIXED_COLOUR_PRIORITY)

/obj/item/stack/cable_coil/update_name(updates=ALL)

. = ..()

if(!novariants)

return

name = "cable [amount < 3 ? "piece" : "coil"]"

/obj/item/stack/cable_coil/attack_hand(mob/user)

. = ..()

if(.)

return

var/obj/item/stack/cable_coil/new_cable = ..()

if(istype(new_cable))

new_cable.cable_color = cable_color

new_cable.update_appearance()

//add cables to the stack

/obj/item/stack/cable_coil/proc/give(extra)

if(amount + extra > max_amount)

amount = max_amount

else

amount += extra

update_appearance()

///////////////////////////////////////////////

// Cable laying procedures

//////////////////////////////////////////////

/obj/item/stack/cable_coil/proc/get_new_cable(location)

var/path = /obj/structure/cable

return new path(location, cable_color)

// called when cable_coil is clicked on a turf

/obj/item/stack/cable_coil/proc/place_turf(turf/T, mob/user, dirnew)

if(!isturf(user.loc))

return

if(!isturf(T) || T.underfloor_accessibility < UNDERFLOOR_INTERACTABLE || !T.can_have_cabling())

to_chat(user, span_warning("You can only lay cables on top of exterior catwalks and plating!"))

return

if(get_amount() < 1) // Out of cable

to_chat(user, span_warning("There is no cable left!"))

return

if(get_dist(T,user) > 1) // Too far

to_chat(user, span_warning("You can't lay cable at a place that far away!"))

return

var/dirn

if(!dirnew) //If we weren't given a direction, come up with one! (Called as null from catwalk.dm and floor.dm)

if(user.loc == T)

dirn = user.dir //If laying on the tile we're on, lay in the direction we're facing

else

dirn = get_dir(T, user)

else

dirn = dirnew

for(var/obj/structure/cable/LC in T)

if(LC.d2 == dirn && LC.d1 == 0)

to_chat(user, span_warning("There's already a cable at that position!"))

return

var/obj/structure/cable/C = get_new_cable(T)

//set up the new cable

C.d1 = 0 //it's a O-X node cable

C.d2 = dirn

C.add_fingerprint(user)

C.update_appearance()

//create a new powernet with the cable, if needed it will be merged later

var/datum/powernet/PN = new()

PN.add_cable(C)

C.mergeConnectedNetworks(C.d2) //merge the powernet with adjacents powernets

C.mergeConnectedNetworksOnTurf() //merge the powernet with on turf powernets

if(C.d2 & (C.d2 - 1))// if the cable is layed diagonally, check the others 2 possible directions

C.mergeDiagonalsNetworks(C.d2)

use(1)

if(C.shock(user, 50))

if(prob(50)) //fail

new /obj/item/stack/cable_coil(get_turf(C), 1, C.color)

C.deconstruct()

return C

// called when cable_coil is click on an installed obj/cable

// or click on a turf that already contains a "node" cable

/obj/item/stack/cable_coil/proc/cable_join(obj/structure/cable/C, mob/user, showerror = TRUE, forceddir)

var/turf/U = user.loc

if(!isturf(U))

return

var/turf/T = C.loc

if(!isturf(T) || T.underfloor_accessibility < UNDERFLOOR_INTERACTABLE || !T.can_have_cabling())

to_chat(user, span_warning("You can only lay cables on top of exterior catwalks and plating!"))

return

if(get_amount() < 1) // Out of cable

to_chat(user, span_warning("There is no cable left!"))

return

if(get_dist(C, user) > 1) // make sure it's close enough

to_chat(user, span_warning("You can't lay cable at a place that far away!"))

return

if(U == T && !forceddir) //if clicked on the turf we're standing on and a direction wasn't supplied, try to put a cable in the direction we're facing

place_turf(T,user)

return

var/dirn = get_dir(C, user)

if(forceddir)

dirn = forceddir

// one end of the clicked cable is pointing towards us and no direction was supplied

if((C.d1 == dirn || C.d2 == dirn) && !forceddir)

if(!U.can_have_cabling()) //checking if it's a plating or catwalk

if (showerror)

to_chat(user, span_warning("You can only lay cables on catwalks and plating!"))

return

if(U.underfloor_accessibility < UNDERFLOOR_INTERACTABLE) //can't place a cable if it's a plating with a tile on it

to_chat(user, span_warning("You can't lay cable there unless the floor tiles are removed!"))

return

else

// cable is pointing at us, we're standing on an open tile

// so create a stub pointing at the clicked cable on our tile

var/fdirn = turn(dirn, 180) // the opposite direction

for(var/obj/structure/cable/LC in U) // check to make sure there's not a cable there already

if(LC.d1 == fdirn || LC.d2 == fdirn)

if (showerror)

to_chat(user, span_warning("There's already a cable at that position!"))

return

var/obj/structure/cable/NC = get_new_cable (U)

NC.d1 = 0

NC.d2 = fdirn

NC.add_fingerprint(user)

NC.update_appearance()

//create a new powernet with the cable, if needed it will be merged later

var/datum/powernet/newPN = new(loc.z)

newPN.add_cable(NC)

NC.mergeConnectedNetworks(NC.d2) //merge the powernet with adjacents powernets

NC.mergeConnectedNetworksOnTurf() //merge the powernet with on turf powernets

if(NC.d2 & (NC.d2 - 1))// if the cable is layed diagonally, check the others 2 possible directions

NC.mergeDiagonalsNetworks(NC.d2)

use(1)

if (NC.shock(user, 50))

if (prob(50)) //fail

NC.deconstruct()

return

// exisiting cable doesn't point at our position or we have a supplied direction, so see if it's a stub

else if(C.d1 == 0)

// if so, make it a full cable pointing from it's old direction to our dirn

var/nd1 = C.d2 // these will be the new directions

var/nd2 = dirn

if(nd1 > nd2) // swap directions to match icons/states

nd1 = dirn

nd2 = C.d2

for(var/obj/structure/cable/LC in T) // check to make sure there's no matching cable

if(LC == C) // skip the cable we're interacting with

continue

if((LC.d1 == nd1 && LC.d2 == nd2) || (LC.d1 == nd2 && LC.d2 == nd1) ) // make sure no cable matches either direction

if (showerror)

to_chat(user, span_warning("There's already a cable at that position!"))

return

C.update_appearance()

C.d1 = nd1

C.d2 = nd2

//updates the stored cable coil

C.add_fingerprint(user)

C.update_appearance()

C.mergeConnectedNetworks(C.d1) //merge the powernets...

C.mergeConnectedNetworks(C.d2) //...in the two new cable directions

C.mergeConnectedNetworksOnTurf()

if(C.d1 & (C.d1 - 1))// if the cable is layed diagonally, check the others 2 possible directions

C.mergeDiagonalsNetworks(C.d1)

if(C.d2 & (C.d2 - 1))// if the cable is layed diagonally, check the others 2 possible directions

C.mergeDiagonalsNetworks(C.d2)

use(1)

if (C.shock(user, 50))

if (prob(50)) //fail

C.deconstruct()

return

C.denode()// this call may have disconnected some cables that terminated on the centre of the turf, if so split the powernets.

return

/obj/item/stack/cable_coil/cyborg

is_cyborg = 1

materials = list()

cost = 1

/obj/item/stack/cable_coil/cyborg/attack_self(mob/user)

var/picked = tgui_input_list(user, "Pick a cable color.","Cable Color", GLOB.cable_colors)

cable_color = picked

update_appearance(UPDATE_ICON)

//////////////////////////////

// Misc.

/////////////////////////////

/obj/item/stack/cable_coil/red

cable_color = CABLE_COLOR_RED

color = CABLE_HEX_COLOR_RED

/obj/item/stack/cable_coil/yellow

cable_color = CABLE_COLOR_YELLOW

color = CABLE_HEX_COLOR_YELLOW

/obj/item/stack/cable_coil/blue

cable_color = CABLE_COLOR_BLUE

color = CABLE_HEX_COLOR_BLUE

/obj/item/stack/cable_coil/green

cable_color = CABLE_COLOR_GREEN

color = CABLE_HEX_COLOR_GREEN

/obj/item/stack/cable_coil/pink

cable_color = CABLE_COLOR_PINK

color = CABLE_HEX_COLOR_PINK

/obj/item/stack/cable_coil/orange

cable_color = CABLE_COLOR_ORANGE

color = CABLE_HEX_COLOR_ORANGE

/obj/item/stack/cable_coil/cyan

cable_color = CABLE_COLOR_CYAN

color = CABLE_HEX_COLOR_CYAN

/obj/item/stack/cable_coil/white

cable_color = CABLE_COLOR_WHITE

color = CABLE_HEX_COLOR_WHITE

/obj/item/stack/cable_coil/brown

cable_color = CABLE_COLOR_BROWN

color = CABLE_HEX_COLOR_BROWN

/obj/item/stack/cable_coil/random

cable_color = null

color = CABLE_HEX_COLOR_WHITE

/obj/item/stack/cable_coil/random/thirty

amount = 30

/obj/item/stack/cable_coil/random/five

amount = 5

/obj/item/stack/cable_coil/cut

amount = null

icon_state = "coil2"

/obj/item/stack/cable_coil/cut/Initialize(mapload)

if(!amount)

amount = rand(1,2)

return ..()

/obj/item/stack/cable_coil/cut/red

cable_color = "red"

color = "#ff0000"

/obj/item/stack/cable_coil/cut/yellow

cable_color = "yellow"

color = "#ffff00"

/obj/item/stack/cable_coil/cut/blue

cable_color = "blue"

color = "#1919c8"

/obj/item/stack/cable_coil/cut/green

cable_color = "green"

color = "#00aa00"

/obj/item/stack/cable_coil/cut/pink

cable_color = "pink"

color = "#ff3ccd"

/obj/item/stack/cable_coil/cut/orange

cable_color = "orange"

color = "#ff8000"

/obj/item/stack/cable_coil/cut/cyan

cable_color = "cyan"

color = "#00ffff"

/obj/item/stack/cable_coil/cut/white

cable_color = "white"

/obj/item/stack/cable_coil/cut/random

cable_color = null

color = "#ffffff"

#undef CABLE_RESTRAINTS_COST