mirror of
https://github.com/Bubberstation/Bubberstation.git
synced 2025-12-11 18:22:14 +00:00
3330cd9ae8
## About The Pull Request See https://github.com/spacestation13/hypnagogic/releases/tag/v5.0.0 for more details. Some of this is just updating our existing .toml files to support the changes to input vars (bools became enums). I'm also taking the opportunity to implement autocutting for diagonal (read: shuttle mostly) walls, which should be the LAST THING IN THE CODEBASE that wasn't autocut. Hopefully this means none ever handcuts something ever again. I hope. Oh also [Removes /turf/closed/indestructible/syndicate/nodiagonal as it does not do anything](df735ab0e6) The parent is also not diagonal so it doesn't like, do anything at all. [cleans up redundant restoration artifacts](552454fbf4) Restoration step doesn't know about templates, so it just sort of puts in everything that NEEDS to be in there (or tries to). This leads to artifacts when a template is included, shouldn't have those in the codebase they don't do anything. ## Why It's Good For The Game No more handcut bullshit. Wallem asked me for directional cutting support, now we have that so art folk can use it for stuff.
469 lines
19 KiB
Plaintext
469 lines
19 KiB
Plaintext
|
|
//generic (by snowflake + others) tile smoothing code; smooth your icons with this!
|
|
/*
|
|
Smoothed atoms are displayed using prebaked icon states which have been "cut" from a template to match a set of possible smoothing directions.
|
|
This allows for a variety of effects, such as nice wall textures, gloopy slime, carpet that makes sense, etc etc etc
|
|
|
|
To use this, just set your atom's 'smoothing_flags' var to SMOOTH_BITMASK. There are other smoothing strategies but that's all we need to worry about right now
|
|
If you don't want your atom's icon to smooth with anything but atoms of the same type, set the string 'canSmoothWith' to null;
|
|
Otherwise, put all the smoothing groups you want the atom icon to smooth with in 'canSmoothWith', including the group of the atom itself.
|
|
Smoothing groups are just shared flags between objects. If one of the 'canSmoothWith' of A matches one of the `smoothing_groups` of B, then A will smooth with B.
|
|
|
|
Each atom has its own icon file with all its icon states, this file is typically generated automatically from a png/toml using hypnagoic, our external cutter.
|
|
See `wall.dmi' 'wall.png' and 'wall.png.toml' for an example, alongside [the icon cutter documentation](../../icons/Cutter.md)
|
|
|
|
DIAGONAL SMOOTHING INSTRUCTIONS
|
|
To make your atom smooth diagonally you need all the proper icon states (hypnagoic does not support these currently, TODO)
|
|
They're constructed out of 12 "corners", 4 outer corners, 4 "outside" inner corners and 4 "inside" inner corners
|
|
- 5, 6, 9 and 10 get what you can think of as "outside" bars, they're corners with no inside, like below (smoothing from the POV of [X]).
|
|
- [X]X
|
|
- X
|
|
- 21, 38, 74, 137 get "inside" bars, still built with the same "outside" edges.
|
|
- [X]X
|
|
- X X
|
|
I shouldn't like, need to tell you this, ideally hypnagogic would just support it, but I haven't done that yet and I wanted to write this down for now.
|
|
|
|
Then add the 'SMOOTH_DIAGONAL_CORNERS' flag to the atom's smoothing_flags var (in addition to SMOOTH_BITMASK).
|
|
|
|
For turfs, what appears under the diagonal corners depends on the turf that was in the same position previously: if you make a wall on
|
|
a plating floor, you will see plating under the diagonal wall corner, if it was space, you will see space.
|
|
|
|
If you wish to map a diagonal wall corner with a fixed underlay, you must configure the turf's 'fixed_underlay' list var, like so:
|
|
fixed_underlay = list("icon"='icon_file.dmi', "icon_state"="iconstatename")
|
|
A non null 'fixed_underlay' list var will skip copying the previous turf appearance and always use the list. If the list is
|
|
not set properly, the underlay will default to regular floor plating.
|
|
NOTE: a special case of this involves setting fixed_underlay to list("space" = TRUE), which will force it to draw space below the wall, no matter what
|
|
|
|
To see an example of a diagonal wall, see '/turf/closed/wall/mineral/titanium' and its subtypes.
|
|
|
|
BORDER SMOOTHING INSTRUCTIONS
|
|
Ok so we have code to smooth border objects together, unfortunately for you I don't remember how they're supposed to be rendered (AND WE HAVE NO CUTTER SUPPORT)
|
|
I'll fill this in when/if I add proper cutting for these, they're so painful to put together by hand I don't really want to even describe it to you
|
|
|
|
ADVANCED FILTERING INSTRUCTIONS
|
|
Smoothing allows you to manually filter out potential smoothing oppertunities by toggling SMOOTH_PROC_FILTER
|
|
(or SMOOTH_BORDER_OBJECT but you should just be calling should_border_obj_smooth()) and overriding smoothing_allowed(atom/smoothing_with, direction, junction)
|
|
This gives you control over if two atoms filter together, and what junction they will use (you likely do not want to touch this)
|
|
|
|
PLEASE NOTE: you are giving up the convenience features of smoothing autoupdating if an input changes. If you do this you need to update and such MANUALLY.
|
|
ALSO NOTE: this function cannot have side effects, as it is called when other atoms attempt to smooth with YOU as well.
|
|
*/
|
|
|
|
GLOBAL_LIST_INIT(adjacent_direction_lookup, generate_adjacent_directions())
|
|
|
|
/* Attempting to mirror the below
|
|
* Each 3x3 grid is a tile, with each X representing a direction a border object could be in IN said grid
|
|
* Directions marked with A are acceptable smoothing targets, M is the example direction
|
|
* The example given here is of a northfacing border object
|
|
xxx AxA xxx
|
|
xxx AxA xxx
|
|
xxx AxA xxx
|
|
|
|
AAA MMM AAA
|
|
xxx AxA xxx
|
|
xxx AxA xxx
|
|
|
|
xxx xxx xxx
|
|
xxx xxx xxx
|
|
xxx xxx xxx
|
|
*/
|
|
/// Encodes connectivity between border objects
|
|
/// Returns a list accessable by a border object's dir, the direction between it and a target, and a target
|
|
/// Said list will return the direction the two objects connect, if any exists (if the target isn't a border object and the direction is fine, return the inverse of the direction in use)
|
|
/proc/generate_adjacent_directions()
|
|
// Have to hold all conventional dir pairs, so we size to the largest
|
|
// We don't HAVE diagonal border objects, so I'm gonna pretend they'll never exist
|
|
|
|
// You might be like, lemon, can't we use GLOB.cardinals/GLOB.alldirs here
|
|
// No, they aren't loaded yet. life is pain
|
|
var/list/cardinals = list(NORTH, SOUTH, EAST, WEST)
|
|
var/list/alldirs = cardinals + list(NORTH|EAST, SOUTH|EAST, NORTH|WEST, SOUTH|WEST)
|
|
var/largest_cardinal = max(cardinals)
|
|
var/largest_dir = max(alldirs)
|
|
|
|
var/list/direction_map = new /list(largest_cardinal)
|
|
for(var/dir in cardinals)
|
|
var/left = turn(dir, 90)
|
|
var/right = turn(dir, -90)
|
|
var/opposite = REVERSE_DIR(dir)
|
|
// Need to encode diagonals here because it's possible, even if it is always false
|
|
var/list/acceptable_adjacents = new /list(largest_dir)
|
|
// Alright, what directions are acceptable to us
|
|
for(var/connectable_dir in (cardinals + NONE))
|
|
// And what border objects INSIDE those directions are alright
|
|
var/list/smoothable_dirs = new /list(largest_cardinal + 1) // + 1 because we need to provide space for NONE to be a valid index
|
|
// None is fine, we want to smooth with things on our own turf
|
|
// We'll do the two dirs to our left and right
|
|
// They connect.. "below" us and on their side
|
|
if(connectable_dir == NONE)
|
|
smoothable_dirs[left] = dir_to_junction(opposite | left)
|
|
smoothable_dirs[right] = dir_to_junction(opposite | right)
|
|
// If it's to our right or left we'll include just the dir matching ours
|
|
// Left edge touches only our left side, and so on
|
|
else if (connectable_dir == left)
|
|
smoothable_dirs[dir] = left
|
|
else if (connectable_dir == right)
|
|
smoothable_dirs[dir] = right
|
|
// If it's straight on we'll include our direction as a link
|
|
// Then include the two edges on the other side as diagonals
|
|
else if(connectable_dir == dir)
|
|
smoothable_dirs[opposite] = dir
|
|
smoothable_dirs[left] = dir_to_junction(dir | left)
|
|
smoothable_dirs[right] = dir_to_junction(dir | right)
|
|
// otherwise, go HOME, I don't want to encode anything for you
|
|
else
|
|
continue
|
|
acceptable_adjacents[connectable_dir + 1] = smoothable_dirs
|
|
direction_map[dir] = acceptable_adjacents
|
|
return direction_map
|
|
|
|
/// Helper proc for smoothing border objects. Return this from smoothing_allowed() to get the desired effect
|
|
/// Indexes into some global lists that encode direction bullshit
|
|
/proc/should_border_obj_smooth(atom/border_obj, atom/target, direction)
|
|
// If the target is also a border obj, take its dirs into account
|
|
if(target.smoothing_flags & SMOOTH_BORDER_OBJECT)
|
|
return GLOB.adjacent_direction_lookup[border_obj?.dir || NORTH][direction + 1]?[target.dir]
|
|
// Otherwise, do it normal style
|
|
if(GLOB.adjacent_direction_lookup[border_obj?.dir || NORTH][direction + 1])
|
|
return REVERSE_DIR(direction)
|
|
return NONE
|
|
|
|
///do not use, use QUEUE_SMOOTH(atom)
|
|
/atom/proc/smooth_icon()
|
|
if(QDELETED(src))
|
|
return
|
|
smoothing_flags &= ~SMOOTH_QUEUED
|
|
flags_1 |= HTML_USE_INITAL_ICON_1
|
|
if (!z)
|
|
CRASH("[type] called smooth_icon() without being on a z-level")
|
|
if(smoothing_flags & (SMOOTH_BITMASK|SMOOTH_BITMASK_CARDINALS))
|
|
bitmask_smooth()
|
|
else
|
|
CRASH("smooth_icon called for [src] with smoothing_flags == [smoothing_flags]")
|
|
SEND_SIGNAL(src, COMSIG_ATOM_SMOOTHED_ICON)
|
|
|
|
// As a rule, movables will most always care about smoothing changes
|
|
// Turfs on the other hand, don't, so we don't do the update for THEM unless they explicitly request it
|
|
/atom/movable/smooth_icon()
|
|
. = ..()
|
|
update_appearance(~UPDATE_SMOOTHING)
|
|
|
|
/**
|
|
* Allows for more direct control over filtering smoothing targets. Only runs if SMOOTH_PROC_FILTER (OR SMOOTH_BORDER_OBJECT) is enabled
|
|
* Called as a final point of decision on if a smooth should go through or not.
|
|
*
|
|
* NOTE: this proc NEEDS TO BE pure (same result if inputs with the same state are passed in, has no side effects)
|
|
* You are taking some control away from the smoothing system, so you also need to force an update if something you are dependent on changes. This can be hard.
|
|
*
|
|
* atom/smoothing_with : the atom we are attemption to smooth with, or null if SMOOTH_BORDER is set and we're talking to the edge of the map
|
|
* direction : the cardinal direction from us to our target atom (provided for convenience)
|
|
* junction : the smoothing junction this atom would normally lie on (you almost always want to return this)
|
|
*
|
|
* Returns the junction to use (you almost always want this to just be junction)
|
|
*/
|
|
/atom/proc/smoothing_allowed(atom/smoothing_with, direction, junction)
|
|
SHOULD_BE_PURE(TRUE)
|
|
stack_trace("Unoverrided call to allow_smooth by [type], if you're going to have SMOOTH_PROC_FILTER (or SMOOTH_BORDER_OBJECT) set you need to do something with it")
|
|
return NONE
|
|
|
|
/**
|
|
* Basic smoothing proc. The atom checks for adjacent directions to smooth with and changes the icon_state based on that.
|
|
*
|
|
* Returns the previous smoothing_junction state so the previous state can be compared with the new one after the proc ends, and see the changes, if any.
|
|
*
|
|
*/
|
|
/atom/proc/bitmask_smooth()
|
|
var/new_junction = NONE
|
|
|
|
// cache for sanic speed
|
|
var/canSmoothWith = src.canSmoothWith
|
|
var/area/home_base = get_area(src)
|
|
var/area_limited_icon_smoothing = home_base?.area_limited_icon_smoothing
|
|
|
|
var/smooth_border = (smoothing_flags & SMOOTH_BORDER)
|
|
var/smooth_obj = (smoothing_flags & SMOOTH_OBJ)
|
|
var/border_object_smoothing = (smoothing_flags & SMOOTH_BORDER_OBJECT)
|
|
var/smooth_proc_filter = (smoothing_flags & SMOOTH_PROC_FILTER)
|
|
var/just_set_junction = !(border_object_smoothing || smooth_proc_filter)
|
|
|
|
#define SEARCH_ADJ_IN_DIR(direction, direction_flag) \
|
|
do { \
|
|
set_adj_in_dir: { \
|
|
var/turf/neighbor = get_step(src, direction); \
|
|
if(neighbor && (!area_limited_icon_smoothing || istype(neighbor.loc, area_limited_icon_smoothing))) { \
|
|
var/neighbor_smoothing_groups = neighbor.smoothing_groups; \
|
|
if(neighbor_smoothing_groups) { \
|
|
SMOOTH_AGAINST(neighbor, direction, direction_flag, neighbor_smoothing_groups); \
|
|
} \
|
|
if(smooth_obj) { \
|
|
for(var/atom/movable/thing as anything in neighbor) { \
|
|
var/thing_smoothing_groups = thing.smoothing_groups; \
|
|
if(!thing.anchored || isnull(thing_smoothing_groups)) { \
|
|
continue; \
|
|
}; \
|
|
SMOOTH_AGAINST(thing, direction, direction_flag, thing_smoothing_groups); \
|
|
} \
|
|
} \
|
|
} else if (smooth_border) { \
|
|
JUNCTION_FOUND(null, direction, direction_flag); \
|
|
} \
|
|
} \
|
|
} while(FALSE)
|
|
|
|
#define SMOOTH_AGAINST(thing, direction, direction_flag, their_groups) \
|
|
for(var/target in canSmoothWith) { \
|
|
if(canSmoothWith[target] & their_groups[target] && \
|
|
(!(thing.smoothing_flags & SMOOTH_PROC_FILTER) || thing.smoothing_allowed(src, REVERSE_DIR(direction), reverse_junction(direction_flag)))) { \
|
|
JUNCTION_FOUND(thing, direction, direction_flag); \
|
|
} \
|
|
}
|
|
|
|
#define JUNCTION_FOUND(target, direction, direction_flag) \
|
|
if (just_set_junction) { \
|
|
new_junction |= direction_flag; \
|
|
break set_adj_in_dir; \
|
|
} \
|
|
if (border_object_smoothing) { \
|
|
new_junction |= smoothing_allowed(target, direction, direction_flag); \
|
|
break; /* border objects can find more then one junction on one turf, sooo */ \
|
|
} \
|
|
if(smooth_proc_filter) { \
|
|
var/old_junction = new_junction; \
|
|
new_junction |= smoothing_allowed(target, direction, direction_flag); \
|
|
if(old_junction == new_junction) { \
|
|
break; \
|
|
} \
|
|
break set_adj_in_dir; \
|
|
}
|
|
|
|
// Let's go over all our cardinals
|
|
if(border_object_smoothing)
|
|
SEARCH_ADJ_IN_DIR(NORTH, NORTH)
|
|
SEARCH_ADJ_IN_DIR(SOUTH, SOUTH)
|
|
SEARCH_ADJ_IN_DIR(EAST, EAST)
|
|
SEARCH_ADJ_IN_DIR(WEST, WEST)
|
|
// We want to check against stuff in our own turf
|
|
SEARCH_ADJ_IN_DIR(NONE, NONE)
|
|
// Border objects don't do diagonals, so GO HOME
|
|
set_smoothed_icon_state(new_junction)
|
|
return
|
|
|
|
SEARCH_ADJ_IN_DIR(NORTH, NORTH)
|
|
SEARCH_ADJ_IN_DIR(SOUTH, SOUTH)
|
|
SEARCH_ADJ_IN_DIR(EAST, EAST)
|
|
SEARCH_ADJ_IN_DIR(WEST, WEST)
|
|
|
|
// If there's nothing going on already
|
|
if(smoothing_flags & SMOOTH_BITMASK_CARDINALS || !(new_junction & (NORTH|SOUTH)) || !(new_junction & (EAST|WEST)))
|
|
set_smoothed_icon_state(new_junction)
|
|
return
|
|
|
|
if(new_junction & NORTH_JUNCTION)
|
|
if(new_junction & WEST_JUNCTION)
|
|
SEARCH_ADJ_IN_DIR(NORTHWEST, NORTHWEST_JUNCTION)
|
|
|
|
if(new_junction & EAST_JUNCTION)
|
|
SEARCH_ADJ_IN_DIR(NORTHEAST, NORTHEAST_JUNCTION)
|
|
|
|
if(new_junction & SOUTH_JUNCTION)
|
|
if(new_junction & WEST_JUNCTION)
|
|
SEARCH_ADJ_IN_DIR(SOUTHWEST, SOUTHWEST_JUNCTION)
|
|
|
|
if(new_junction & EAST_JUNCTION)
|
|
SEARCH_ADJ_IN_DIR(SOUTHEAST, SOUTHEAST_JUNCTION)
|
|
|
|
set_smoothed_icon_state(new_junction)
|
|
|
|
#undef JUNCTION_FOUND
|
|
#undef SMOOTH_AGAINST
|
|
#undef SEARCH_ADJ_IN_DIR
|
|
|
|
#define DEFAULT_UNDERLAY_ICON 'icons/turf/floors.dmi'
|
|
#define DEFAULT_UNDERLAY_ICON_STATE "plating"
|
|
|
|
///Changes the icon state based on the new junction bitmask
|
|
/atom/proc/set_smoothed_icon_state(new_junction)
|
|
. = smoothing_junction
|
|
smoothing_junction = new_junction
|
|
icon_state = "[base_icon_state]-[smoothing_junction]"
|
|
|
|
/turf/closed/set_smoothed_icon_state(new_junction)
|
|
// Avoid calling ..() here to avoid setting icon_state twice, which is expensive given how hot this proc is
|
|
var/old_junction = smoothing_junction
|
|
smoothing_junction = new_junction
|
|
|
|
if (!(smoothing_flags & SMOOTH_DIAGONAL_CORNERS))
|
|
icon_state = "[base_icon_state]-[smoothing_junction]"
|
|
return
|
|
|
|
switch(new_junction)
|
|
if(
|
|
NORTH_JUNCTION|WEST_JUNCTION,
|
|
NORTH_JUNCTION|EAST_JUNCTION,
|
|
SOUTH_JUNCTION|WEST_JUNCTION,
|
|
SOUTH_JUNCTION|EAST_JUNCTION,
|
|
NORTH_JUNCTION|WEST_JUNCTION|NORTHWEST_JUNCTION,
|
|
NORTH_JUNCTION|EAST_JUNCTION|NORTHEAST_JUNCTION,
|
|
SOUTH_JUNCTION|WEST_JUNCTION|SOUTHWEST_JUNCTION,
|
|
SOUTH_JUNCTION|EAST_JUNCTION|SOUTHEAST_JUNCTION,
|
|
)
|
|
icon_state = "[base_icon_state]-[smoothing_junction]-diagonal"
|
|
if(new_junction == old_junction || fixed_underlay) // Mutable underlays?
|
|
return
|
|
|
|
var/junction_dir = reverse_ndir(smoothing_junction)
|
|
var/turned_adjacency = REVERSE_DIR(junction_dir)
|
|
var/turf/neighbor_turf = get_step(src, turned_adjacency & (NORTH|SOUTH))
|
|
var/mutable_appearance/underlay_appearance = mutable_appearance(layer = LOW_FLOOR_LAYER, offset_spokesman = src, plane = FLOOR_PLANE)
|
|
if(!neighbor_turf.get_smooth_underlay_icon(underlay_appearance, src, turned_adjacency))
|
|
neighbor_turf = get_step(src, turned_adjacency & (EAST|WEST))
|
|
|
|
if(!neighbor_turf.get_smooth_underlay_icon(underlay_appearance, src, turned_adjacency))
|
|
neighbor_turf = get_step(src, turned_adjacency)
|
|
|
|
if(!neighbor_turf.get_smooth_underlay_icon(underlay_appearance, src, turned_adjacency))
|
|
if(!get_smooth_underlay_icon(underlay_appearance, src, turned_adjacency)) //if all else fails, ask our own turf
|
|
underlay_appearance.icon = DEFAULT_UNDERLAY_ICON
|
|
underlay_appearance.icon_state = DEFAULT_UNDERLAY_ICON_STATE
|
|
underlays += underlay_appearance
|
|
else
|
|
icon_state = "[base_icon_state]-[smoothing_junction]"
|
|
|
|
/turf/open/floor/set_smoothed_icon_state(new_junction)
|
|
if(broken || burnt)
|
|
return
|
|
return ..()
|
|
|
|
#undef DEFAULT_UNDERLAY_ICON
|
|
#undef DEFAULT_UNDERLAY_ICON_STATE
|
|
|
|
//Icon smoothing helpers
|
|
/proc/smooth_zlevel(zlevel, now = FALSE)
|
|
var/list/away_turfs = Z_TURFS(zlevel)
|
|
for(var/turf/turf_to_smooth as anything in away_turfs)
|
|
if(turf_to_smooth.smoothing_flags & USES_SMOOTHING)
|
|
if(now)
|
|
turf_to_smooth.smooth_icon()
|
|
else
|
|
QUEUE_SMOOTH(turf_to_smooth)
|
|
for(var/atom/movable/movable_to_smooth as anything in turf_to_smooth)
|
|
if(movable_to_smooth.smoothing_flags & USES_SMOOTHING)
|
|
if(now)
|
|
movable_to_smooth.smooth_icon()
|
|
else
|
|
QUEUE_SMOOTH(movable_to_smooth)
|
|
|
|
/atom/proc/set_can_smooth_with(canSmoothWith)
|
|
if(!canSmoothWith)
|
|
src.canSmoothWith = null
|
|
return
|
|
PARSE_CAN_SMOOTH_WITH(canSmoothWith, src.canSmoothWith, smoothing_flags)
|
|
|
|
/atom/proc/set_smoothing_groups(smoothing_groups)
|
|
if(!smoothing_groups)
|
|
src.smoothing_groups = null
|
|
return
|
|
PARSE_SMOOTHING_GROUPS(smoothing_groups, src.smoothing_groups)
|
|
|
|
/// Takes a direction, turns it into all the junctions that contain it
|
|
/proc/dir_to_all_junctions(dir)
|
|
var/handback = NONE
|
|
if(dir & NORTH)
|
|
handback |= NORTH_JUNCTION | NORTHEAST_JUNCTION | NORTHWEST_JUNCTION
|
|
if(dir & SOUTH)
|
|
handback |= SOUTH_JUNCTION | SOUTHEAST_JUNCTION | SOUTHWEST_JUNCTION
|
|
if(dir & EAST)
|
|
handback |= EAST_JUNCTION | SOUTHEAST_JUNCTION | NORTHEAST_JUNCTION
|
|
if(dir & WEST)
|
|
handback |= WEST_JUNCTION | NORTHWEST_JUNCTION | SOUTHWEST_JUNCTION
|
|
return handback
|
|
|
|
/proc/dir_to_junction(dir)
|
|
switch(dir)
|
|
if(NORTH)
|
|
return NORTH_JUNCTION
|
|
if(SOUTH)
|
|
return SOUTH_JUNCTION
|
|
if(WEST)
|
|
return WEST_JUNCTION
|
|
if(EAST)
|
|
return EAST_JUNCTION
|
|
if(NORTHWEST)
|
|
return NORTHWEST_JUNCTION
|
|
if(NORTHEAST)
|
|
return NORTHEAST_JUNCTION
|
|
if(SOUTHEAST)
|
|
return SOUTHEAST_JUNCTION
|
|
if(SOUTHWEST)
|
|
return SOUTHWEST_JUNCTION
|
|
else
|
|
return NONE
|
|
|
|
/proc/reverse_junction(junction)
|
|
var/handback = NONE
|
|
if(junction & NORTH_JUNCTION)
|
|
handback |= SOUTH_JUNCTION
|
|
if(junction & SOUTH_JUNCTION)
|
|
handback |= NORTH_JUNCTION
|
|
if(junction & EAST_JUNCTION)
|
|
handback |= WEST_JUNCTION
|
|
if(junction & WEST_JUNCTION)
|
|
handback |= EAST_JUNCTION
|
|
if(junction & NORTHEAST_JUNCTION)
|
|
handback |= SOUTHWEST_JUNCTION
|
|
if(junction & SOUTHWEST_JUNCTION)
|
|
handback |= NORTHEAST_JUNCTION
|
|
if(junction & NORTHWEST_JUNCTION)
|
|
handback |= SOUTHEAST_JUNCTION
|
|
if(junction & SOUTHEAST_JUNCTION)
|
|
handback |= NORTHWEST_JUNCTION
|
|
return handback
|
|
|
|
/proc/reverse_ndir(ndir)
|
|
switch(ndir)
|
|
if(NORTH_JUNCTION)
|
|
return NORTH
|
|
if(SOUTH_JUNCTION)
|
|
return SOUTH
|
|
if(WEST_JUNCTION)
|
|
return WEST
|
|
if(EAST_JUNCTION)
|
|
return EAST
|
|
if(NORTHWEST_JUNCTION)
|
|
return NORTHWEST
|
|
if(NORTHEAST_JUNCTION)
|
|
return NORTHEAST
|
|
if(SOUTHEAST_JUNCTION)
|
|
return SOUTHEAST
|
|
if(SOUTHWEST_JUNCTION)
|
|
return SOUTHWEST
|
|
if(NORTH_JUNCTION | WEST_JUNCTION)
|
|
return NORTHWEST
|
|
if(NORTH_JUNCTION | EAST_JUNCTION)
|
|
return NORTHEAST
|
|
if(SOUTH_JUNCTION | WEST_JUNCTION)
|
|
return SOUTHWEST
|
|
if(SOUTH_JUNCTION | EAST_JUNCTION)
|
|
return SOUTHEAST
|
|
if(NORTH_JUNCTION | WEST_JUNCTION | NORTHWEST_JUNCTION)
|
|
return NORTHWEST
|
|
if(NORTH_JUNCTION | EAST_JUNCTION | NORTHEAST_JUNCTION)
|
|
return NORTHEAST
|
|
if(SOUTH_JUNCTION | WEST_JUNCTION | SOUTHWEST_JUNCTION)
|
|
return SOUTHWEST
|
|
if(SOUTH_JUNCTION | EAST_JUNCTION | SOUTHEAST_JUNCTION)
|
|
return SOUTHEAST
|
|
else
|
|
return NONE
|
|
|
|
|
|
//Example smooth wall
|
|
/turf/closed/wall/smooth
|
|
name = "smooth wall"
|
|
icon = 'icons/turf/smooth_wall.dmi'
|
|
icon_state = "smooth_wall-0"
|
|
base_icon_state = "smooth_wall"
|
|
smoothing_flags = SMOOTH_BITMASK|SMOOTH_DIAGONAL_CORNERS|SMOOTH_BORDER
|
|
smoothing_groups = SMOOTH_GROUP_TEST_WALL
|
|
canSmoothWith = SMOOTH_GROUP_TEST_WALL
|