DUL_colorcode_message:
type: procedure
debug: false
DUL:
author:
- BlackCoyote
description:
- Encodes your message into a colour code string and back.
- only works with characters from a-z, 0-9, and _ !
usage:
- <proc[DUL_colorcode_message].context[encode/decode|<message>]>
example:
- <proc[DUL_colorcode_message].context[encode|my_sword_id]>
encode:
a: '&0&0'
b: '&0&1'
c: '&0&2'
d: '&0&3'
e: '&0&4'
f: '&0&5'
g: '&0&6'
h: '&0&7'
i: '&0&8'
j: '&0&9'
k: '&1&0'
l: '&1&1'
m: '&1&2'
n: '&1&3'
o: '&1&4'
p: '&1&5'
q: '&1&6'
r: '&1&7'
s: '&1&8'
t: '&1&9'
u: '&2&0'
v: '&2&1'
w: '&2&2'
x: '&2&3'
y: '&2&4'
z: '&2&5'
0: '&2&6'
1: '&2&7'
2: '&2&8'
3: '&2&9'
4: '&3&0'
5: '&3&1'
6: '&3&2'
7: '&3&3'
8: '&3&4'
9: '&3&5'
_: '&3&6'
decode:
'&0&0': a
'&0&1': b
'&0&2': c
'&0&3': d
'&0&4': e
'&0&5': f
'&0&6': g
'&0&7': h
'&0&8': i
'&0&9': j
'&1&0': k
'&1&1': l
'&1&2': m
'&1&3': n
'&1&4': o
'&1&5': p
'&1&6': q
'&1&7': r
'&1&8': s
'&1&9': t
'&2&0': u
'&2&1': v
'&2&2': w
'&2&3': x
'&2&4': y
'&2&5': z
'&2&6': 0
'&2&7': 1
'&2&8': 2
'&2&9': 3
'&3&0': 4
'&3&1': 5
'&3&2': 6
'&3&3': 7
'&3&4': 8
'&3&5': 9
'&3&6': _
script:
- if li@encode|decode !contains <def[1]||> {
- debug error "DUL - No valid action specified! Must be encode or decode!"
- determine null
}
- if <def[2]||> == "" {
- debug error "DUL - No message specified to <def[1]>!"
- determine null
}
- define result ""
- if <def[1]> == encode {
- define list <def[2].to_list>
} else {
- define list li@
- define 2 <def[2].escaped.replace[&ss].with[&]>
- repeat <def[2].length.div[4].as_int> {
- define list <def[list].include[<def[2].substring[<def[value].mul[4].sub[4].add[1]||1>,<def[value].mul[4]>]>]>
}
}
- foreach <def[list]>:
- define result "<def[result]><script.yaml_key[<def[1]>.<def[value]>]||->"
- determine <def[result].parse_color>
DUL_ColorList:
type: procedure
debug: false
DUL:
author:
- Anthony
name:
- ColorList
description:
- Return colors from input or just list all colors
usage:
- <proc[DUL_colorlist].context[<list/match|input>]>
example:
- narrate <proc[DUL_colorlist].context[list]>
- narrate <proc[DUL_colorlist].context[match|blu]>
colors:
black: 0
dark_blue: 1
dark_green: 2
dark_aqua: 3
dark_red: 4
dark_purple: 5
gold: 6
gray: 7
dark_gray: 8
blue: 9
green: a
aqua: b
red: c
light_purple: d
yellow: e
white: f
magic: k
bold: l
strikethrough: m
underline: n
italic: o
reset: r
script:
- define colors '<script.list_keys[colors]>'
- choose '<def[1]>':
- case 'list':
- define list 'li@'
- foreach '<def[colors]>':
- define list '<def[list].include[<el@val[&<script.yaml_key[colors.%value%]>]> %value%]>'
- determine '<def[list]>'
- case 'match':
- determine '<proc[DUL_find_best_match].context[<def[colors]>|<def[2]>]>'
+DUL_cuboid_vertices:
+ type: procedure
+ debug: false
+ DUL:
+ author:
+ - Anthony
+ name:
+ - Cuboid Vertices
+ description:
+ - Return the list of cuboid vertices from a location pair.
+ usage:
+ - <proc[DUL_cuboid_vertices].context[%loc1%|%loc2%]>
+ example:
+ - <proc[DUL_cuboid_vertices].context[<l@0,0,0,world>|<l@1,1,1,world>]>
+
+ script:
+ - define lx '<def[1].x>'
+ - define ly '<def[1].y>'
+ - define lz '<def[1].z>'
+ - define hx '<def[2].x>'
+ - define hy '<def[2].y>'
+ - define hz '<def[2].z>'
+ - define world '<def[1].world.name>'
+ - determine 'li@l@<def[lx]>,<def[ly]>,<def[lz]>,<def[world]>|l@<def[lx]>,<def[hy]>,<def[lz]>,<def[world]>|l@<def[lx]>,<def[ly]>,<def[hz]>,<def[world]>|l@<def[hx]>,<def[ly]>,<def[lz]>,<def[world]>|l@<def[hx]>,<def[hy]>,<def[hz]>,<def[world]>|l@<def[lx]>,<def[hy]>,<def[hz]>,<def[world]>|l@<def[hx]>,<def[hy]>,<def[lz]>,<def[world]>|l@<def[hx]>,<def[ly]>,<def[hz]>,<def[world]>'
+
+
+# Scrapped for flames, keeping for lulz
+#DUL_cuboid_vertices:
+# type: procedure
+# debug: false
+# DUL:
+# author:
+# - Anthony
+# name:
+# - Cuboid Vertices
+# description:
+# - Return the list of cuboid vertices from a location pair.
+# usage:
+# - <proc[DUL_cuboid_vertices].context[%loc1%|%loc2%]>
+# example:
+# - <proc[DUL_cuboid_vertices].context[<l@0,0,0,world>|<l@1,1,1,world>]>
+
+# script:
+# - define world '<def[1].world.name>'
+# - foreach 'li@x|y|z':
+# - define %value%pair 'li@<def[1].%value%>|<def[2].%value%>'
+# - define vertlist 'li@'
+# - foreach '<def[xpair]>':
+# - define x '%value%'
+# - foreach '<def[ypair]>':
+# - define y '%value%'
+# - foreach '<def[zpair]>':
+# - define vertlist '<def[vertlist].include[l@%x%,%y%,%value%,%world%]>'
+# - determine '%vertlist%'
+
+
+DUL_cuboid_overlap:
+ type: procedure
+ debug: false
+ DUL:
+ author:
+ - Anthony
+ name:
+ - Cuboid Vertices
+ description:
+ - Returns a cuboid object from 2 overlapping cuboids
+ usage:
+ - <proc[DUL_cuboid_overlap].context[%cuboid1%|%cuboid2%]>
+ example:
+ - <proc[DUL_cuboid_overlap].context[<cu@0,0,0,world|l@4,4,4,world>|<cu@3,3,3,world|l@5,5,5,world>]>
+
+ script:
+ # Reconstruct cuboids from list
+ - define objects '<def[raw_context].as_list>'
+ - define 'c1' '<def[objects].get[1].to[2].as_cuboid>'
+ - define 'c2' '<def[objects].get[3].to[4].as_cuboid>'
+ - define 1l '<def[c1].min>'
+ - define 1h '<def[c1].max>'
+ - define world '<def[1l].world.name>'
+ - define 1lx '<def[1l].x>'
+ - define 1ly '<def[1l].y>'
+ - define 1lz '<def[1l].z>'
+ - define 1hx '<def[1h].x>'
+ - define 1hy '<def[1h].y>'
+ - define 1hz '<def[1h].z>'
+ - define 2l '<def[c2].min>'
+ - define 2h '<def[c2].max>'
+ - define 2lx '<def[2l].x>'
+ - define 2ly '<def[2l].y>'
+ - define 2lz '<def[2l].z>'
+ - define 2hx '<def[2h].x>'
+ - define 2hy '<def[2h].y>'
+ - define 2hz '<def[2h].z>'
+ - if ( %1lx% >= %2lx% ) && ( %1lx% <= %2hx% ) {
+ - define flx '%1lx%'
+ }
+ else {
+ - define flx '%2lx%'
+ }
+ - if ( %1ly% >= %2ly% ) && ( %1ly% <= %2hy% ) {
+ - define fly '%1ly%'
+ }
+ else {
+ - define fly '%2ly%'
+ }
+ - if ( %1lz% >= %2lz% ) && ( %1lz% <= %2hz% ) {
+ - define flz '%1lz%'
+ }
+ else {
+ - define flz '%2lz%'
+ }
+ - if ( %1hx% >= %2lx% ) && ( %1hx% <= %2hx% ) {
+ - define fhx '%1hx%'
+ }
+ else {
+ - define fhx '%2hx%'
+ }
+ - if ( %1hy% >= %2ly% ) && ( %1hy% <= %2hy% ) {
+ - define fhy '%1hy%'
+ }
+ else {
+ - define fhy '%2hy%'
+ }
+ - if ( %1hz% >= %2lz% ) && ( %1hz% <= %2hz% ) {
+ - define fhz '%1hz%'
+ }
+ else {
+ - define fhz '%2hz%'
+ }
+ - determine 'cu@%flx%,%fly%,%flz%,%world%|%fhx%,%fhy%,%fhz%,%world%'
+
+
+DUL_cuboid_shell:
+ type: procedure
+ debug: false
+ DUL:
+ author:
+ - Anthony
+ name:
+ - Cuboid Shell
+ description:
+ - Supply a list of cuboids and returns the list of surface locations.
+ usage:
+ - <proc[DUL_cuboid_shell].context[<cuboid>|...]>
+ example:
+ - <proc[DUL_cuboid_shell].context[<cuboid>|...]>
+ script:
+ # Reconstruct cuboids from list
+ - define objects '<def[raw_context].as_list>'
+ - define clist 'li@'
+ - repeat '<def[objects].size.div[2].round>':
+ - define 'cuboid%value%' '<def[objects].get[<def[value].mul[2].sub[1].round>].to[<def[value].mul[2].round>]>'
+ - define clist '<def[clist].include[cuboid%value%]>'
+ - define blocks 'li@'
+ - define overLaps 'li@'
+ - foreach '%clist%':
+ - define olist '<def[clist].remove[%loop_index%]>'
+ - define cuboid '<def[%value%].as_cuboid>'
+ - define 1l '<def[cuboid].min>'
+ - define 1h '<def[cuboid].max>'
+ - define world '<def[1h].world.name>'
+ - define 1lx '<def[1l].x>'
+ - define 1ly '<def[1l].y>'
+ - define 1lz '<def[1l].z>'
+ - define 1hx '<def[1h].x>'
+ - define 1hy '<def[1h].y>'
+ - define 1hz '<def[1h].z>'
+ - foreach '%olist%':
+ - define this '<def[%value%].as_cuboid>'
+ - if <def[cuboid].intersects[%this%]> {
+ - define 2l '<def[this].min>'
+ - define 2h '<def[this].max>'
+ - define 2lx '<def[2l].x>'
+ - define 2ly '<def[2l].y>'
+ - define 2lz '<def[2l].z>'
+ - define 2hx '<def[2h].x>'
+ - define 2hy '<def[2h].y>'
+ - define 2hz '<def[2h].z>'
+ - if ( %1lx% >= %2lx% ) && ( %1lx% <= %2hx% ) {
+ - define flx '%1lx%'
+ }
+ else {
+ - define flx '%2lx%'
+ }
+ - if ( %1ly% >= %2ly% ) && ( %1ly% <= %2hy% ) {
+ - define fly '%1ly%'
+ }
+ else {
+ - define fly '%2ly%'
+ }
+ - if ( %1lz% >= %2lz% ) && ( %1lz% <= %2hz% ) {
+ - define flz '%1lz%'
+ }
+ else {
+ - define flz '%2lz%'
+ }
+ - if ( %1hx% >= %2lx% ) && ( %1hx% <= %2hx% ) {
+ - define fhx '%1hx%'
+ }
+ else {
+ - define fhx '%2hx%'
+ }
+ - if ( %1hy% >= %2ly% ) && ( %1hy% <= %2hy% ) {
+ - define fhy '%1hy%'
+ }
+ else {
+ - define fhy '%2hy%'
+ }
+ - if ( %1hz% >= %2lz% ) && ( %1hz% <= %2hz% ) {
+ - define fhz '%1hz%'
+ }
+ else {
+ - define fhz '%2hz%'
+ }
+ - define oShell 'cu@l@%flx%,%fly%,%flz%,%world%|l@%fhx%,%fhy%,%flz%,%world%|l@%flx%,%fly%,%flz%,%world%|l@%flx%,%fhy%,%fhz%,%world%|l@%flx%,%fly%,%flz%,%world%|l@%fhx%,%fly%,%fhz%,%world%|l@%fhx%,%fhy%,%fhz%,%world%|l@%flx%,%fly%,%fhz%,%world%|l@%fhx%,%fhy%,%fhz%,%world%|l@%fhx%,%fly%,%flz%,%world%|l@%fhx%,%fhy%,%fhz%,%world%|l@%flx%,%fhy%,%flz%,%world%'
+ - define overLaps '<def[overlaps].include[<def[oShell].blocks>]>'
+ }
+ - define shell 'cu@l@%1lx%,%1ly%,%1lz%,%world%|l@%1hx%,%1hy%,%1lz%,%world%|l@%1lx%,%1ly%,%1lz%,%world%|l@%1lx%,%1hy%,%1hz%,%world%|l@%1lx%,%1ly%,%1lz%,%world%|l@%1hx%,%1ly%,%1hz%,%world%|l@%1hx%,%1hy%,%1hz%,%world%|l@%1lx%,%1ly%,%1hz%,%world%|l@%1hx%,%1hy%,%1hz%,%world%|l@%1hx%,%1ly%,%1lz%,%world%|l@%1hx%,%1hy%,%1hz%,%world%|l@%1lx%,%1hy%,%1lz%,%world%'
+ - define blocks '<def[blocks].include[<def[shell].blocks>]>'
+ - determine '<def[blocks].deduplicate.exclude[<def[overLaps].deduplicate>]>'
+
+#
+# Just a some commands to play with
+#
+#DUL_Commands_ShowOverlap:
+# type: command
+# debug: false
+# name: showoverlap
+# description: Show the overlapping area of two cuboids
+# usage: /showoverlap
+# aliases: ''
+
+# tab complete:
+# - determine 'li@'
+
+# script:
+# - showfake m@white_stained_glass <proc[DUL_cuboid_shell].context[<proc[DUL_cuboid_overlap].context[<c.args.get[1].as_cuboid>|<c.args.get[2].as_cuboid>]>]> to:<player> d:<player.flag[dWE.show].split[/].get[2]||10>s
+
+
+#DUL_Commands_Showshell:
+# type: command
+# debug: false
+# name: showshell
+# description: Show the shell of two cuboids
+# usage: /showshell
+# aliases: ''
+
+# tab complete:
+# - determine 'li@'
+
+# script:
+# - showfake m@white_stained_glass <proc[DUL_cuboid_shell].context[<c.args.get[1].as_cuboid>|<c.args.get[2].as_cuboid>]> to:<player> d:<player.flag[dWE.show].split[/].get[2]||10>s
+
+#
DUL_find_best_match:
type: procedure
debug: false
DUL:
author:
- BlackCoyote
- Anthony
description:
- Returns the best search match out of a list.
usage:
- <proc[DUL_find_best_match].context[<list>|<value>]>
example:
- <proc[DUL_find_best_match].context[<server.flag[homes].as_list>|<context.args.get[1]>]>
script:
- - define l '<queue.definitions.numerical>'
- - define list 'li@'
- - foreach '<def[l]>':
- - define list '<def[list].include[<def[%loop_index%]>]>'
+ - define list '<def[raw_context].as_list||li@>'
+ - if <def[list].size> < 2 {
+ - debug error "DUL - Must provide at least one value to match and one value to match against!"
+ - determine null
+ }
- define match '<def[list].last>'
- define list '<def[list].remove[<def[list].size>]>'
- - if <def[list].is_empty||true> {
- - debug error "DUL - No valid list specified!"
- - determine null
- }
- - if <def[match]||null> == null {
- - debug error "DUL - No valid value specified!"
- - determine null
- }
- if <def[list].contains[<def[match]>]> {
- - determine <def[match]>
+ - determine '<def[match]>'
} else if <def[list].filter[starts_with[<def[match]>]].size||0> > 0 {
- - determine <def[list].filter[starts_with[<def[match]>]].sort_by_number[length].first||null>
+ - determine '<def[list].filter[starts_with[<def[match]>]].sort_by_number[length].first||null>'
} else if <def[list].filter[contains[<def[match]>]].size||0> > 0 {
- - determine <def[list].filter[contains[<def[match]>]].sort_by_number[length].first||null>
+ - determine '<def[list].filter[contains[<def[match]>]].sort_by_number[length].first||null>'
} else {
- determine null
}
DUL_hidden_spawn_locations:
type: procedure
debug: false
definitions: location|radius
DUL:
author:
- BlackCoyote
description:
- Finds spawn locations within range that are out of line of sight.
- If no locations out of line of sight are found, it will return valid spawn locations within line of sight.
usage:
- <proc[DUL_hidden_spawn_locations].context[<l@location>|<radius>]>
example:
- <proc[DUL_hidden_spawn_locations].context[<player.location>|15]>
script:
- if <def[location]||null> !matches location {
- debug error "DUL - No valid location specified!"
- determine null
}
- if <def[radius]||null> !matches number {
- debug error "DUL - No valid radius specified!"
- determine null
}
- define radius <def[radius].as_int>
- determine <def[location].find.surface_blocks.within[<def[radius]>].filter[y.sub[<def[location].y>].abs.is[less].than[3]].filter[above.above.above.material.name.is[==].to[air]].filter[above.above.above.above.material.name.is[==].to[air]].filter[above.above.above.above.above.material.name.is[==].to[air]].filter[material.is_occluding].parse[above].filter[above.center.line_of_sight[<def[location].add[0,1.5,0].center>].not]||<def[location].find.surface_blocks.within[<def[radius]>]||li@<def[location]>>>
+DUL_parse_colors_without_url:
+ type: procedure
+ debug: false
+ DUL:
+ author:
+ - BlackCoyote
+ description:
+ - parses the color codes in the input whilst skipping the ones within URLs.
+ usage:
+ - <proc[DUL_parse_colors_without_url].context[<escape message>]>
+ example:
+ - <proc[DUL_parse_colors_without_url].context[<context.message.escaped>]>
+ script:
+ - if <def[1]||null> == null {
+ - determine null
+ }
+ - define message ""
+ - foreach <def[1].split_by[<&sp>]>:
+ - define string <def[value].unescaped>
+ - if <def[string].starts_with[http<&co>//]> || <def[string].starts_with[https<&co>//]> || <def[string].starts_with[www.]> {
+ - define message "<def[message]><def[string]> "
+ } else {
+ - define message "<def[message]><def[string].parse_color> "
+ }
+ - determine <def[message].trim>
DUL_rainbow_text:
type: procedure
debug: false
DUL:
author:
- BlackCoyote
description:
- Turns the colour of a text into a rainbow format with a new colour per letter.
usage:
- <proc[DUL_rainbow_text].context[<text.escaped>]>
example:
- <proc[DUL_rainbow_text].context[<context.message.escaped>]>
script:
- if <def[1].exists.not> {
- debug error "DUL - No valid text specified!"
- determine null
}
- define colormap li@<&4>|<&6>|<&e>|<&a>|<&3>|<&9>|<&5>
- define result ""
- foreach <def[1].unescaped.to_list.escape_contents>:
- define result "<def[result]><def[colormap].get[<def[loop_index].sub[1].mod[7].add[1].as_int>]><def[value]>"
- determine <def[result].unescaped>
DUL_random_surface_block:
type: procedure
definitions: location|radius
debug: false
DUL:
author:
- BlackCoyote
description:
- Finds a random surface block within the provided radius more efficiently than conventional denizen tags.
usage:
- <proc[DUL_random_surface_block].context[<l@location>|<radius>]>
example:
- <proc[DUL_random_surface_block].context[<player.location>|5000]>
script:
- if <def[location]||null> !matches location {
- debug error "DUL - No valid location specified!"
- determine null
}
- if <def[radius]||null> !matches number {
- debug error "DUL - No valid radius specified!"
- determine null
}
- while true:
- define newloc <def[location].add[<util.random.int[<def[radius].mul[-1]>].to[<def[radius]>]>,0,<util.random.int[<def[radius].mul[-1]>].to[<def[radius]>]>].highest.find.surface_blocks.within[5].get[1]||null>
- if <def[newloc]> != null && <def[newloc].material.is_occluding> {
- determine <def[newloc].above>
} else if <def[loop_index]> >= 10 {
- determine null
}
DUL_safeString:
type: procedure
debug: false
DUL:
author:
- Anthony
name:
- Safe String
description:
- Boolean tag returns true if the string only contains lower case letters, numbers, and/or underscore _
usage:
- <proc[DUL_safeString].context[string]>
example:
- narrate <proc[DUL_safeString].context[check_this_string]>
script:
- determine '<def[1].matches[^[a-z0-9-_]+$]>'
DUL_cleanString:
type: procedure
debug: false
DUL:
author:
- Anthony
name:
- Clean String
description:
- Clean a string of any character that is not a lower case letter, number, or underscore _
usage:
- <proc[DUL_cleanString].context[string]>
example:
- narrate <proc[DUL_cleanString].context[cleanA_thi&s_string]>
script:
- determine '<def[1].replace[regex:[^a-z0-9-_]]>'
#
DUL_script_tracker:
type: world
debug: false
events:
on system time hourly:
- webget "http://morphanone.space/webizen.aspx/tracker?script=96&version=<s@DUL_version_script.yaml_key[version]>"
DUL_text_progress_bar:
type: procedure
debug: false
DUL:
author:
- BlackCoyote
description:
- Makes a text based progress bar based on the percentage you provide.
usage:
- <proc[DUL_text_progress_bar].context[<percentage>(|<size>|<character>|<color1>|<color2>)]>
example:
- <proc[DUL_text_progress_bar].context[<player.health.percentage>]>
script:
- define percentage <def[1]||0>
- if <def[percentage].as_int||none> == none {
- define percentage 0
}
- if <def[2].exists> {
- define max <def[2]>
}
- if <def[max].as_int||none> == none {
- define max 10
}
- if <def[3].exists> {
- define char <def[3].substring[1,1]||=>
} else {
- define char =
}
- if <def[4].exists> {
- define col1 <def[4]>
} else {
- define col1 &a
}
- if <def[5].exists> {
- define col2 <def[5]>
} else {
- define col2 &7
}
- define string <el@.pad_right[<def[max]>].with[<def[char]>]>
- define split <def[max].div[100].mul[<def[percentage]>].as_int>
- determine "<def[col1].parse_colors><def[string].substring[1,<def[split]>]><def[col2].parse_colors><def[string].substring[<def[split].add[1].as_int>,<def[max]>]>"
DUL_unique_queue_id_prefixed:
type: procedure
debug: false
DUL:
author:
- BlackCoyote
description:
- Gives a unique queue ID for you to use, with a specified prefix.
usage:
- <proc[DUL_unique_queue_id_prefixed].context[<prefix>]>
example:
- <proc[DUL_unique_queue_id_prefixed].context[DUL_<player>]>
script:
- define prefix <def[1]||>
- define id <def[prefix]><util.random.duuid>
- while <queue.list.parse[id].contains[<def[id]>]>:
- define id <def[prefix]><util.random.duuid>
- determine <def[id]>
DUL_version_script:
type: version
name: dUtilLib
id: 96
description: A collection of dscript functions and utilities written by BlackCoyote and Anthony.
- version: 8
+ version: 11
DUL_WRCG:
type: procedure
debug: false
DUL:
author:
- Anthony
name:
- Weighted Random Choice Generator
description:
- Supply a list of weight/return values and have one of the values returned to you randomly based on weight.
usage:
- <proc[DUL_WRCG].context[weight/return|...]>
example:
- give <proc[DUL_WRCG].context[10/i@apple|1/i@gold_ingot|20/i@stone]>
script:
- - define l 'li@'
+ - define l '<def[raw_context].as_list>'
- - foreach '<queue.definitions.exclude[l]>':
- - define l '<def[l].include[<def[%value%]>]>'
- define w '0'
- foreach '<def[l].parse[before[/]]>':
- define w '<def[w].add[%value%]>'
- define number '<util.random.int[1].to[%w%]>'
- define hv '0'
- foreach '%l%':
- define ov '%hv%'
- define lv '<def[ov].add[1]>'
- define hv '<def[ov].add[<def[value].before[/]>]>'
- if %number% >= %lv% && %number% <= %hv% {
- determine '<def[value].after[/]>'
}
-