################################################################################
#
# d R e g i o n s
#
#
# Authors: |Anthony|
# Version: 0.3
# dScript Version: 0.9.6-DEV_b140
#
#
# Dependencies:
#
# - dWorldEditor
# - Integrates with region selection wand
# - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/dWE/dWorldEditor.yml
#
# - ConfigFileGenerator
# - Used to build default config files and data storage.
# - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/ConfigFileGenerator.yml
#
# - Flags
# - All the flags for dRegions. It will be bundled in eventually.
# - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/dRegions/flags.dscript
#
#_______________________________________________________________________________
#
#--- About dRegions
#
# dRegions is an advanced region management and world protection system written
# with the Denizen Scripting Engine. Heavily inspired by WorldGuard, the goal is
# to have an extremely efficient events system supporting an exhaustive set of
# region flags and configuration options. dRegions offers an intuitive command
# interface and provides thorough TAB completion.
#
#
#--- Installation & Setup
#
# Install Flags, ConfigFileGenerator, dWorldEditor, and dRegions to your scripts
# folder and reload scripts. /denizen reload scripts
#
# All config and data storage files will be automatically generated in your
# Denizen plugin folder. /plugins/Denizen/dRegions
#
#
#--- Permissions & Commands
#
# Here's a list of all the permissions and commands with a brief description
# of each. More verbose usage info can be found in game. /drg help
#
# dRegions provides thorough TAB completion! Use this to your benefit!
#
# The permissions system isn't fully realized yet. Meanwhile, we have a list of
# generic permissions to get you by.
#
# /drg help [arg/#] dregions.help Specify a page number or command arg
# /drg define dregions.define Define a region
# /drg redefine dregions.redefine Update region to new selection
# /drg claim dregions.claim Claim the selected region
# /drg select dregions.select Select a region by id
# /drg remove dregions.remove Remove a region
# /drg list dregions.list List regions
# /drg info dregions.info See info on a region
# /drg addowner dregions.addowner Add a player or perm group as a region owner
# /drg removeowner dregions.removeowner Remove a player or perm group from region owner
# /drg addmember dregions.addmember Add a player or perm group as a region member
# /drg removemember dregions.removemember Remove a player or perm group from region member
# /drg flag dregions.flag Set region flags
# /drg setpriority dregions.setpriority Set region priority
# /drg setparent dregions.setparent Set region parent
# /drg teleport dregions.teleport Teleport to region
# /drg reload dregions.reload Reload all config files
# /drg restart dregions.restart Restart dRegions for whatever reason
# dregions.admin Override permission for all things dRegions
#
# dregions.invincible Makes the player totally invincible
# dregions.invincible.<cause> Player can't be damaged by specific cause(s)
#
#--- Basic Usage Tutorial
#
# After you've gotten installed, setup, and permissions assigned (op-only mode
# is fine too), you will need to give yourself a region wand. /dwe wand
#
# Mark your region selection using the wand as directed.
#
# Define your region noting any owners (player or -g group) you want
# - /drg define myRegion notch herobrine -g members -g vip
#
# Your region is now protected! *Still indev! Not all protections implemented!*
#
# Set region priority
# - /drg setpriority myRegion 10
#
# Set any region flags you need
# - /drg flag myRegion greeting Hello <player.name>!
#
#
################################################################################
#
# dRegions World Events Script
#
# This should cover all dRegions related world events.
#
#
dRegions:
type: world
speed: 0
debug: false
events:
##################################################
#
# World Events
#
#
on server start:
- run locally start delay:2t
on world initializes:
- run locally loadYaml instantly
on script reload:
- run locally start instantly
on command:
- if <context.server||false> {
- queue clear
}
- define world '<player.world.name>'
- define target '<c.command.to_lowercase> <c.raw_args.to_lowercase>'
- if <c.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Commands'
- inject s@dRegions_Flag_Commands p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Commands'
- inject s@dRegions_Flag_Commands p:event
# on structure grows:
# - announce "Grew <context.structure>"
# - announce "<player.name||unknown>"
on block ignites:
- define world '<c.location.world.name>'
- define target '<c.location.material.bukkit_enum>'
- define readPath 'fire.<c.cause>'
- if <c.cause> == flint_and_steel {
- define cause 'Lighter'
}
else {
- define cause 'Fire-Spread'
}
# - define cause '<t[<c.cause.is[==].to[flint_and_steel]>]:Lighter||Fire-Spread>'
- inject s@dRegions p:event_PreProc_Config
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.%cause%.%target%]||null>'
- if %cache% == false {
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_%cause%'
- inject s@dRegions_Flag_%cause% p:event-global
}
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_%cause%'
- inject %FlagScript% p:event
on block burns:
- define world '<c.location.world.name>'
- define target '<c.location.material.bukkit_enum>'
- define readPath 'fire.destroyBlocks'
- inject s@dRegions p:event_PreProc_Config
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.fire-destroy.%target%]||null>'
- if %cache% == false {
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Fire-Destroy'
- inject s@dRegions_Flag_Fire-Destroy p:event-global
}
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.fire-spread.%target%]||null>'
- if %cache% == false {
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Fire-Spread'
- inject s@dRegions_Flag_Fire-Spread p:event-global
}
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Fire-Destroy'
- inject s@dRegions_Flag_Fire-Destroy p:event
- define FlagScript 's@dRegions_Flag_Fire-Spread'
- inject s@dRegions_Flag_Fire-Spread p:event
on ice forms:
- define world '<c.location.world.name>'
- define readPath 'blockform.ice'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.ice-form]||null>'
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Ice-Form'
- inject s@dRegions_Flag_Ice-Form p:event-global
- queue clear
}
# - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
# - if %lCache% != null {
# - define orderedRegions '%lCache%'
# }
# else {
# - define regionPri 'li@'
# - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
# - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
# }
# - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
# }
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Ice-Form'
- inject s@dRegions_Flag_Ice-Form p:event
on snow forms:
- define world '<c.location.world.name>'
- define target '<c.location.sub[0,1,0].material.bukkit_enum>'
- define readPath 'blockform.snow'
- inject s@dRegions p:event_PreProc_Config
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.snow-fall.%target%]||null>'
- if %cache% == false {
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Snow-Fall'
- inject s@dRegions_Flag_Snow-Fall p:event-global
}
- queue clear
}
# - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
# - if %lCache% != null {
# - define orderedRegions '%lCache%'
# }
# else {
# - define regionPri 'li@'
# - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
# - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
# }
# - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
# }
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Snow-Fall'
- inject s@dRegions_Flag_Snow-Fall p:event
on soil fades:
- define world '<c.location.world.name>'
- define readPath 'blockfade.soil'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.soil-dry]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Soil-Dry'
- inject s@dRegions_Flag_Soil-Dry p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Soil-Dry'
- inject s@dRegions_Flag_Soil-Dry p:event
on ice fades:
- define world '<c.location.world.name>'
- define readPath 'blockfade.ice'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.ice-melt]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Ice-Melt'
- inject s@dRegions_Flag_Ice-Melt p:event-global
- queue clear
}
# - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
# - if %lCache% != null {
# - define orderedRegions '%lCache%'
# }
# else {
# - define regionPri 'li@'
# - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
# - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
# }
# - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
# }
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Ice-Melt'
- inject s@dRegions_Flag_Ice-Melt p:event
on snow fades:
- define world '<c.location.world.name>'
- define readPath 'blockfade.snow'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.snow-melt]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Snow-Melt'
- inject s@dRegions_Flag_Snow-Melt p:event-global
- queue clear
}
# - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
# - if %lCache% != null {
# - define orderedRegions '%lCache%'
# }
# else {
# - define regionPri 'li@'
# - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
# - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
# }
# - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
# }
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Snow-Melt'
- inject s@dRegions_Flag_Snow-Melt p:event
on block spreads:
- define mat '<c.material.bukkit_enum.split[_].last>'
- if li@grass|mycel|mushroom|vines !contains %mat% queue clear
- define world '<c.location.world.name>'
- define readPath 'spread.%mat%'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.%mat%-spread]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_%mat%-Spread'
- inject %FlagScript% p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_%mat%-Spread'
- inject %FlagScript% p:event
on liquid spreads:
- if <c.location.material.bukkit_enum> == <c.destination.material.bukkit_enum> queue clear
- define mat '<c.location.material.bukkit_enum.split[_].last>'
- define target '<c.destination.material.bukkit_enum>'
- define world '<c.location.world.name>'
- define readPath 'spread.%mat%'
- inject s@dRegions p:event_PreProc_Config
- if <c.destination.cuboids.include[<c.location.cuboids>].is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.%mat%-spread.%target%]||null>'
- if %cache% == false {
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_%mat%-Spread'
- inject s@dRegions_Flag_%mat%-Spread p:event-global
}
- queue clear
}
# Build list of dRegions for <c.destination> in priority order
- define regionPri 'li@'
- foreach <c.destination.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# Block liquid from crossing region borders
- if <c.location.cuboids.alphanumeric.unseparated||null> != <c.destination.cuboids.alphanumeric.unseparated||null> {
# Build list of dRegions for <c.location> in priority order
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define oldLoc '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]].get[1]>'
- if %oldLoc% != <def[orderedRegions].get[1]> {
- determine cancelled
}
}
- define FlagScript 's@dRegions_Flag_%mat%-Spread'
- inject s@dRegions_Flag_%mat%-Spread p:event
on lightning strikes:
- define world '<c.world.name>'
- define target '<c.location.below.material.bukkit_enum>'
- define readPath 'lightning-strike'
- inject s@dRegions p:event_PreProc_Config
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.lightning-strikes.%target%]||null>'
- if %cache% == false {
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Lightning-Strikes'
- inject s@dRegions_Flag_Lightning-Strikes p:event-global
}
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Lightning-Strikes'
- inject s@dRegions_Flag_Lightning-Strikes p:event
on leaves decay:
- define world '<c.location.world.name>'
- define readPath 'leaf-decay'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.leaf-decay]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Leaf-Decay'
- inject s@dRegions_Flag_Leaf-Decay p:event-global
- queue clear
}
# - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
# - if %lCache% != null {
# - define orderedRegions '%lCache%'
# }
# else {
# - define regionPri 'li@'
# - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
# - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
# }
# - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
# }
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Leaf-Decay'
- inject s@dRegions_Flag_Leaf-Decay p:event
on portal created:
- define world '<c.world.name.to_lowercase>'
- define readPath 'portal.create'
- inject s@dRegions p:event_PreProc_Config-NoTarget
on potion splash:
# This will cancel the splash if any entity is in a protected region!
- define world '<c.location.world.name>'
- define cuboids '<c.entities.parse[location.cuboids].deduplicate>'
- if <def[cuboids].is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.potion-throw]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- run s@dRegions_Flag_Potion-Throw msg delay:1t
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Potion-Throw'
- inject s@dRegions_Flag_Potion-Throw p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Potion-Throw'
- inject s@dRegions_Flag_Potion-Throw p:event
on piston extends:
- define world '<c.location.world.name>'
- define lastBlock '<tern[<c.length.is[==].to[0]||true>]:<c.relative>||<c.relative.sub[<c.location>].add[<c.blocks.last>]>>'
- if <c.blocks.include[%lastBlock%].parse[cuboids].is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.pistons]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Pistons'
- inject s@dRegions_Flag_Pistons p:event-global
- queue clear
}
- if <c.location.cuboids.alphanumeric.unseparated||null> != <c.blocks.include[%lastBlock%].parse[cuboids].deduplicate.alphanumeric.unseparated||null> {
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define pistonCuboid '<def[orderedRegions].get[1]>'
- foreach <c.blocks.include[%lastBlock%]> {
- define cuboids <def[value].cuboids>
- define regionPri 'li@'
- foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define nextLocCuboids '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- if <def[pistonCuboid].is[!=].to[<def[nextLocCuboids].get[1]>]> {
- determine cancelled
}
}
}
- if <def[orederedRegions].exists.not> {
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
}
- define FlagScript 's@dRegions_Flag_Pistons'
- inject s@dRegions_Flag_Pistons p:event
on piston retracts:
- define world '<c.location.world.name>'
- define lastBlock '<tern[<c.length.is[==].to[0]||true>]:<c.relative>||<c.relative.sub[<c.location>].add[<c.blocks.last>]>>'
- if <c.blocks.include[%lastBlock%].parse[cuboids].is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.pistons]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Pistons'
- inject s@dRegions_Flag_Pistons p:event-global
- queue clear
}
- if <c.location.cuboids.alphanumeric.unseparated||null> != <c.blocks.include[%lastBlock%].parse[cuboids].deduplicate.alphanumeric.unseparated||null> {
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define pistonCuboid '<def[orderedRegions].get[1]>'
- foreach <c.blocks.include[%lastBlock%]> {
- define cuboids <def[value].cuboids>
- define regionPri 'li@'
- foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define nextLocCuboids '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- if <def[pistonCuboid].is[!=].to[<def[nextLocCuboids].get[1]>]> {
- determine cancelled
}
}
}
- if <def[orederedRegions].exists.not> {
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
}
- define FlagScript 's@dRegions_Flag_Pistons'
- inject s@dRegions_Flag_Pistons p:event
#
# END World Events
##################################################
#
# Player Events
#
#
# on player clicks block:
# - narrate "item <c.item||i@air>"
# - narrate "mat <c.location.material.bukkit_enum||air>"
# - narrate "type <c.click_type||unknown>"
# - define world '<player.world.name.to_lowercase>'
# - define cuboids '<c.cuboids>'
# - inject s@dRegions p:event_PreProc_OrderRegionsGlobal
# - define allFlagScripts '<server.list_scripts.filter[starts_with[s@dRegions_Flag_]]||li@>'
# - inject s@dRegions p:use_<c.item||null>
# - inject s@dRegions p:playerClick_<c.type||null>
on player chats:
- define world '<player.world.name>'
- if <player.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Send-Chat'
- inject s@dRegions_Flag_Send-Chat p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Send-Chat'
- inject s@dRegions_Flag_Send-Chat p:event
on player destroys vehicle:
- define world '<player.world.name.to_lowercase>'
- if <c.vehicle.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Vehicle-Destroy'
- inject s@dRegions_Flag_Vehicle-Destroy p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.vehicle.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Vehicle-Destroy'
- inject s@dRegions_Flag_Vehicle-Destroy p:event
on player stands on:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define target '<c.location.material.bukkit_enum>'
- define sameRegion 'true'
- define rateLimit '<player.flag[dRegions.rateLimit.use-switches.%target%]||null>'
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- run s@dRegions_Flag_Use-Switches p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
}
- define world '<player.world.name>'
- if <c.cuboids.is_empty||true> {
- define cache '<player.flag[dRegions.cache.%world%.__global__.use-switches.%target%]||null>'
- if %cache% == false {
- flag <player> dRegions.rateLimit.use-switches.%target%:false d:10s
- run s@dRegions_Flag_use-switches p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- if %cache% == null {
- define flagScript 's@dRegions_Flag_Use-Switches'
- inject s@dRegions_Flag_Use-Switches p:event-global
}
- flag <player> dRegions.rateLimit.use-switches.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define flagScript 's@dRegions_Flag_Use-Switches'
- inject s@dRegions_Flag_Use-Switches p:event
on player right clicks block with boat:
- define world '<player.world.name>'
- if <c.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Vehicle-Place'
- inject s@dRegions_Flag_Vehicle-Place p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Vehicle-Place'
- inject s@dRegions_Flag_Vehicle-Place p:event
on player right clicks with potion:
- if !<c.item.potion_effect.is_splash||false> {
- queue clear
}
- define world '<player.world.name>'
- if <player.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Potion-Throw'
- inject s@dRegions_Flag_Potion-Throw p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Potion-Throw'
- inject s@dRegions_Flag_Potion-Throw p:event
on player consumes potion:
- define world '<player.world.name>'
- if <player.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Potion-Drink'
- inject s@dRegions_Flag_Potion-Drink p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Potion-Drink'
- inject s@dRegions_Flag_Potion-Drink p:event
on player right clicks block with armor_stand:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
on player right clicks block with monster_egg:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
on player throws hatching egg:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.egg.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.egg.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
on player right clicks:
- if <player.has_permission[dRegions.admin]> || <player.is_op> {
- queue clear
}
- define target '<c.location.material.bukkit_enum||air>'
- define item '<c.item.material.bukkit_enum||air>'
- if %item% == air {
- define FlagScript '<s@dRegions_Map_Interactions.yaml_key[block.%target%]||null>'
}
else {
- define eventObj '<s@dRegions_Map_Interactions.yaml_key[block_withItem.%target%]||li@>'
- if <def[eventObj].split[/].get[2].as_list||li@> contains %item% {
- define FlagScript '<def[eventObj].split[/].get[1]>'
}
else {
- define FlagScript '<s@dRegions_Map_Interactions.yaml_key[block.%target%]||null>'
}
}
- if %FlagScript% == null {
- queue clear
}
- define flag '<def[FlagScript].after_last[_]>'
- if <c.location.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
- define sameRegion 'true'
- if %flag% == Build {
- define rateLimit '<player.flag[dRegions.rateLimit.%flag%]||null>'
}
else {
- define rateLimit '<player.flag[dRegions.rateLimit.%flag%.%target%]||null>'
}
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- run s@dRegions_Flag_%flag% p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
}
}
else {
- define sameRegion 'false'
}
- define world '<player.world.name>'
- define cuboids '<c.cuboids||<player.location.cursor_on[5].cuboids||li@>>'
- if <def[cuboids].is_empty||true> {
- if %flag% == Build {
- inject %FlagScript% p:event-global
- queue clear
}
- define cache '<player.flag[dRegions.cache.%world%.__global__.%flag%.%target%]||null>'
- if %cache% == false {
- if %sameRegion% flag <player> dRegions.rateLimit.%flag%.%target%:false d:10s
- run s@dRegions_Flag_%flag% p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- if %cache% == null {
- inject s@dRegions_Flag_%flag% p:event-global
}
- if %sameRegion% flag <player> dRegions.rateLimit.%flag%.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- inject %FlagScript% p:event
on player right clicks npc:
- define world '<player.world.name>'
- if <c.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_NPC-Interact'
- inject %FlagScript% p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_NPC-Interact'
- inject s@dRegions_Flag_NPC-Interact p:event
on player right clicks entity:
- if <c.entity.is_player> || <c.entity.is_npc> || <c.entity.entity_type> == item_frame {
- queue clear
}
- define target '<c.entity.entity_type>'
- define rateLimit '<player.flag[dRegions.rateLimit.entity-interact.%target%]||null>'
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- run s@dRegions_Flag_Entity-Interact p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
}
- define world '<player.world.name>'
- if <c.cuboids.is_empty||true> {
- define cache '<player.flag[dRegions.cache.%world%.__global__.entity-interact.%target%]||null>'
- if %cache% == false {
- flag <player> dRegions.rateLimit.entity-interact.%target%:false d:10s
- run s@dRegions_Flag_Entity-Interact p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Entity-Interact'
- inject s@dRegions_Flag_Entity-Interact p:event-global
}
- flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Entity-Interact'
- inject s@dRegions_Flag_Entity-Interact p:event
on player enters bed:
# Do we need to fire events for region enter, exit, and toggle?
# This is a cheat so we don't have to mess about with firing a region entry event.
- if <c.location.cuboids.alphanumeric.unseparated||null> != <player.location.cuboids.alphanumeric.unseparated||null> {
- determine cancelled
}
- define world '<player.world.name>'
- if <c.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Sleep'
- inject s@dRegions_Flag_Sleep p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Sleep'
- inject s@dRegions_Flag_Sleep p:event
# Looks like this isn't needed since the cuboid enter/exit event fires
# on player enters vehicle:
# # Should be doing a check if the cart is in a different cuboid before firing
# # the regionEnter and regionToggle events.
# # Do we need to fire events for regionExit as well?
# # Make vehicle-enter flag for this event!
# - if <c.vehicle.location.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
# - queue clear
# }
# - define world '<player.world.name.to_lowercase>'
# - define isEnter ''
# - if <c.vehicle.location.cuboids.is_empty||true> {
# - define FlagScript 's@dRegions_Flag_Sleep'
# - inject %FlagScript% p:event-global
# - queue clear
# }
# - define regionPri 'li@'
# - foreach <c.vehicle.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
# - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
# }
# - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - foreach <server.flag[dRegions_FlagMap].filter[contains_any[regionEnter|regionToggle]].parse[after[/]].alphanumeric.parse[split[/].get[2]]> {
# - define FlagScript '%value%'
# - inject %value% p:event
# }
on player enters notable cuboid:
# Should we fire an event when the player exits the global region?
# - if <c.from.cuboids.is_empty> {
# - event 'player exits notable cuboid' 'context:cuboids|<c.from.cuboids.escaped>|from|<c.from>|to|<c.to>' save:exit
# - if <entry[exit].determinations.get[1].is[==].to[cancelled]||false> determine cancelled
# }
- flag <player> dRegions.rateLimit:!
- define world '<player.world.name.to_lowercase>'
- define isEnter ''
- define cuboids '<c.cuboids.unescaped.as_list>'
- if <def[cuboids].is_empty||true> {
- define FlagScript 's@dRegions_Flag_Entry'
- inject s@dRegions_Flag_Entry p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Entry'
- inject s@dRegions_Flag_Entry p:event
on player exits notable cuboid:
- define world '<player.world.name.to_lowercase>'
- if <c.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Exit'
- inject s@dRegions_Flag_Exit p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Exit'
- inject s@dRegions_Flag_Exit p:event
- event 'player enters notable cuboid' 'context:cuboids|<c.to.cuboids.escaped>|from|<c.from>|to|<c.to>' save:enter
- if <entry[enter].determinations.get[1]||null> == cancelled {
- determine cancelled
}
on player breaks block:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- define target '<c.material.bukkit_enum>'
- if <c.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
- define sameRegion 'true'
- define rateLimit '<player.flag[dRegions.rateLimit.build]||null>'
- if %rateLimit% != null {
- if !%rateLimit% {
- run s@dRegions_Flag_Build p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
}
- define rateLimit '<player.flag[dRegions.rateLimit.block-break.%target%]||null>'
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- run s@dRegions_Flag_Block-Break p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
}
}
else {
- define sameRegion 'false'
}
- if <c.cuboids.is_empty||true> {
- define cache '<player.flag[dRegions.cache.%world%.__global__.build]||null>'
- if %cache% == false {
- if %sameRegion% flag <player> dRegions.rateLimit.build:false d:10s
- run s@dRegions_Flag_Build p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
}
- if %sameRegion% flag <player> dRegions.rateLimit.build:true d:10s
- define cache '<player.flag[dRegions.cache.%world%.__global__.block-break.%target%]||null>'
- if %cache% == false {
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:false d:10s
- run s@dRegions_Flag_block-break p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_block-break'
- inject s@dRegions_Flag_block-break p:event-global
}
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
- define FlagScript 's@dRegions_Flag_Block-Break'
- inject s@dRegions_Flag_Block-Break p:event
on player places block:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- define target '<c.material.bukkit_enum>'
- if <c.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
- define sameRegion 'true'
- define rateLimit '<player.flag[dRegions.rateLimit.build]||null>'
- if %rateLimit% != null {
- if !%rateLimit% {
- run s@dRegions_Flag_Build p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
}
- define rateLimit '<player.flag[dRegions.rateLimit.block-place.%target%]||null>'
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- run s@dRegions_Flag_Block-Place p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
}
}
else {
- define sameRegion 'false'
}
- if <c.cuboids.is_empty||true> {
- define cache '<player.flag[dRegions.cache.%world%.__global__.build]||null>'
- if %cache% == false {
- if %sameRegion% flag <player> dRegions.rateLimit.build:false d:10s
- run s@dRegions_Flag_Build p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
}
- if %sameRegion% flag <player> dRegions.rateLimit.build:true d:10s
- define cache '<player.flag[dRegions.cache.%world%.__global__.block-place.%target%]||null>'
- if %cache% == false {
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:false d:10s
- run s@dRegions_Flag_block-place p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_block-place'
- inject s@dRegions_Flag_block-place p:event-global
}
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
- define FlagScript 's@dRegions_Flag_Block-Place'
- inject s@dRegions_Flag_Block-Place p:event
on player empties bucket:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.relative.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Bucket-Empty'
- inject s@dRegions_Flag_Bucket-Empty p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.relative.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Bucket-Empty'
- inject s@dRegions_Flag_Bucket-Empty p:event
on player fills bucket:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Bucket-Fill'
- inject s@dRegions_Flag_Bucket-Fill p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Bucket-Fill'
- inject s@dRegions_Flag_Bucket-Fill p:event
on player drops item:
- define world '<player.world.name>'
- define cuboids '<player.location.cuboids.include[<c.location.cuboids>].deduplicate>'
- if <def[cuboids].is_empty||true> {
- define FlagScript 's@dRegions_Flag_Player-Drops'
- inject s@dRegions_Flag_Player-Drops p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Player-Drops'
- inject s@dRegions_Flag_Player-Drops p:event
on player picks up item:
- define world '<player.world.name>'
- define cuboids '<player.location.cuboids.include[<c.location.cuboids>].deduplicate>'
- if <def[cuboids].is_empty||true> {
- define FlagScript 's@dRegions_Flag_Player-Pickup'
- inject s@dRegions_Flag_Player-Pickup p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Player-Pickup'
- inject s@dRegions_Flag_Player-Pickup p:event
on player places hanging:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- define FlagScript 's@dRegions_Flag_Hanging-Place'
- inject s@dRegions_Flag_Hanging-Place p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
- define FlagScript 's@dRegions_Flag_Hanging-Place'
- inject s@dRegions_Flag_Hanging-Place p:event
on player right clicks at armor_stand:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.entity.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
on player right clicks item_frame:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.entity.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
on player damages item_frame:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.entity.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
on player damages player:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<c.entity.world.name>'
- if <c.entity.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.pvp]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- remove <c.projectile||li@>
- run s@dRegions_Flag_PVP msg delay:1t
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_PVP'
- inject s@dRegions_Flag_PVP p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_PVP'
- inject s@dRegions_Flag_PVP p:event
on player damages armor_stand:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<c.entity.world.name>'
- define FlagScript 's@dRegions_Flag_Build'
- if <c.entity.location.cuboids.is_empty||true> {
- inject %FlagScript% p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- inject %FlagScript% p:event
on player damages entity:
- if li@armor_stand|player|item_frame contains <c.entity.prefix> {
- queue clear
}
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define target '<c.entity.entity_type>'
- if <c.entity.location.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
- define rateLimit '<player.flag[dRegions.rateLimit.pve.%target%]||null>'
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- run s@dRegions_Flag_pve p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
}
}
- define world '<c.entity.world.name>'
- define player '<c.damager>'
- define puuid '<c.damager.uuid>'
- if <c.entity.location.cuboids.is_empty> {
- define cache '<player.flag[dRegions.cache.%world%.__global__.pve.%target%]||null>'
- if %cache% == false {
- flag <player> dRegions.rateLimit.FLAG.%target%:false d:10s
- run s@dRegions_Flag_pve p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_pve'
- inject s@dRegions_Flag_pve p:event-global
}
- flag <player> dRegions.rateLimit.pve.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_PVE'
- inject %FlagScript% p:event
on player left clicks block:
- if <c.relative.material.name> != fire {
- queue clear
}
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.relative.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.relative.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
on player clicks block with bone_meal:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- if <c.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
on player damaged:
- define rateLimit '<player.flag[dRegions.rateLimit.player-damage.<c.cause>]||null>'
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- determine cancelled
}
}
- if ( <player.has_permission[dregions.invincible]> || <player.has_permission[dregions.invincible.<c.cause>]> ) && !<player.is_op> {
- flag <player> dRegions.rateLimit.player-damage.%target%:false d:5s
- adjust <player> 'fire_time:0'
- determine cancelled
}
- define world '<c.entity.world.name>'
- define target '<c.cause>'
- define puuid '<player.uuid>'
- define readPath 'player-damage'
- inject s@dRegions p:event_PreProc_Config
- if <c.entity.location.cuboids.is_empty||true> {
- define cache '<player.flag[dRegions.cache.%world%.__global__.player-damage.%target%]||null>'
- if %cache% == false {
- flag <player> dRegions.rateLimit.player-damage.%target%:false d:10s
- adjust <player> 'fire_time:0'
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Player-Damage'
- inject s@dRegions_Flag_Player-Damage p:event-global
}
- flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Player-Damage'
- inject s@dRegions_Flag_Player-Damage p:event
on player changes food level:
- define world '<player.world.name>'
- if <player.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Hunger'
- inject s@dRegions_Flag_Hunger p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Hunger'
- inject s@dRegions_Flag_Hunger p:event
on player teleports:
- if <c.cause> != ender_pearl queue cleard
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<player.world.name>'
- define cuboids '<c.origin.cuboids.include[<c.destination.cuboids>].deduplicate>'
- if <def[cuboids].is_empty||true> {
- define FlagScript 's@dRegions_Flag_Enderpearl'
- inject s@dRegions_Flag_Enderpearl p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Enderpearl'
- inject s@dRegions_Flag_Enderpearl p:event
on player respawns:
- if <player.has_flag[dRegions_Respawn]> {
- adjust <player> 'health:<player.health.max>'
- determine passively '<player.flag[dRegions_Respawn].as_location||<world.spawn_location>>'
- wait 10t
- flag <player> 'dRegions_Respawn:!'
}
#
# END Player Events
##################################################
#
# Mob Events
#
on entity targets entity:
- if <c.target.prefix> == player {
- queue clear
}
- define world '<c.entity.world.name>'
- define attacker '<c.entity>'
- define defender '<c.target>'
- define atarget '<c.entity.entity_type>'
- define dtarget '<c.target.entity_type>'
- if <c.target.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Mob-Attack'
- inject s@dRegions_Flag_Mob-Attack p:event-global
- define FlagScript 's@dRegions_Flag_EVE'
- inject s@dRegions_Flag_EVE p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.target.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Mob-Attack'
- inject s@dRegions_Flag_Mob-Attack p:event
- define FlagScript 's@dRegions_Flag_EVE'
- inject s@dRegions_Flag_EVE p:event
on entity targets player:
- define target '<c.entity.entity_type>'
- define rateLimit '<c.target.flag[dRegions.rateLimit.mob-target.%target%]||null>'
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- determine cancelled
}
}
- define player '<c.target>'
- define world '<c.entity.world.name>'
- define attacker '<c.entity>'
- if <c.target.location.cuboids.is_empty||true> {
- define cache '<c.target.flag[dRegions.cache.%world%.__global__.flag.%target%]||null>'
- if %cache% == false {
- flag <c.target> dRegions.rateLimit.mob-target.%target%:false d:10s
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Mob-Target'
- inject s@dRegions_Flag_Mob-Target p:event-global
}
- flag <c.target> dRegions.rateLimit.mob-target.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <c.target.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Mob-Target'
- inject s@dRegions_Flag_Mob-Target p:event
# This needs to be rewritten cause... idk
#
# on entity damaged by block_explosion:
# - announce "block_explosion <c.cause>"
# - define world '<c.entity.world.name>'
# - if <c.entity.location.cuboids.is_empty||true> {
# - define FlagScript 's@dRegions_Flag_Entity-Explode'
# - inject s@dRegions_Flag_Entity-Explode p:event-global
# - queue clear
# }
# - define regionPri 'li@'
# - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
# - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
# }
# - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - define FlagScript 's@dRegions_Flag_Entity-Explode'
# - inject s@dRegions_Flag_Entity-Explode p:event
on entity damages entity:
- if li@<c.damager.prefix>|<c.entity.prefix> contains player {
- queue clear
}
- define world '<c.entity.world.name>'
- define attacker '<c.damager>'
- define defender '<c.entity>'
- define atarget '<c.damager.entity_type>'
- define dtarget '<c.entity.entity_type>'
- if <c.entity.location.cuboids.is_empty||true> {
# - if <c.cause> == entity_explosion {
# - define target '%atarget%'
# - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.mob-attack.%atarget%]||null>'
# - if %cache% != null {
# - if !%cache% {
# - determine cancelled
# }
# }
# else {
# - define FlagScript 's@dRegions_Flag_Entity-Explode'
# - inject s@dRegions_Flag_Entity-Explode p:event-global
# }
# }
- define FlagScript 's@dRegions_Flag_Mob-Attack'
- inject s@dRegions_Flag_Mob-Attack p:event-global
- define FlagScript 's@dRegions_Flag_EVE'
- inject s@dRegions_Flag_EVE p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - if <c.cause> == entity_explosion {
# - define target '%atarget%'
# - define FlagScript 's@dRegions_Flag_Entity-Explode'
# - inject s@dRegions_Flag_Entity-Explode p:event
# }
- define FlagScript 's@dRegions_Flag_Mob-Attack'
- inject s@dRegions_Flag_Mob-Attack p:event
- define FlagScript 's@dRegions_Flag_EVE'
- inject s@dRegions_Flag_EVE p:event
on entity damages player:
- if <c.damager.prefix> == player {
- queue clear
}
- define target '<c.damager.entity_type>'
- define rateLimit '<c.entity.flag[dRegions.rateLimit.mob-damage.%target%]||null>'
- if %rateLimit% != null {
- if %rateLimit% {
- queue clear
}
else {
- determine cancelled
}
}
- define world '<c.entity.world.name>'
- define attacker '<c.damager>'
- define player '<c.entity>'
- if <c.entity.location.cuboids.is_empty||true> {
# - if <c.cause> == entity_explosion {
# - define FlagScript 's@dRegions_Flag_Entity-Explode'
# - inject s@dRegions_Flag_Entity-Explode p:event-global
# }
- define cache '<c.entity.flag[dRegions.cache.%world%.__global__.flag.%target%]||null>'
- if %cache% == false {
- flag <c.entity> dRegions.rateLimit.mob-damage.%target%:false d:10s
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Mob-Damage'
- inject s@dRegions_Flag_Mob-Damage p:event-global
}
- flag <c.entity> dRegions.rateLimit.mob-damage.%target%:true d:10s
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
# - if <c.cause> == entity_explosion {
# - define FlagScript 's@dRegions_Flag_Entity-Explode'
# - inject s@dRegions_Flag_Entity-Explode p:event
# }
- define FlagScript 's@dRegions_Flag_Mob-Damage'
- inject s@dRegions_Flag_Mob-Damage p:event
on player dies:
- define world '<c.entity.world.name>'
- define target '<c.entity.entity_type>'
- if <c.entity.location.cuboids.is_empty||true> {
- run player:<c.entity> s@dRegions_Flag_Spawn p:event-global def:%world% delay:1t
- define FlagScript 's@dRegions_Flag_Player-KeepItems'
- inject s@dRegions_Flag_Player-KeepItems p:event-global
- define FlagScript 's@dRegions_Flag_Player-Drops-OnDeath'
- inject s@dRegions_Flag_Player-Drops-OnDeath p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- run player:<c.entity> s@dRegions_Flag_Spawn p:event def:%world%|<def[orderedRegions].escaped> delay:1t
- define FlagScript 's@dRegions_Flag_Player-KeepItems'
- inject s@dRegions_Flag_Player-KeepItems p:event
- define FlagScript 's@dRegions_Flag_Player-Drops-OnDeath'
- inject s@dRegions_Flag_Player-Drops-OnDeath p:event
on entity dies:
- if <c.entity.prefix> == player {
- queue clear
}
- define world '<c.entity.world.name>'
- define target '<c.entity.entity_type>'
- if <c.entity.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.entity-drops-ondeath.%target%]||null>'
- if %cache% == false {
- determine no_drops
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Entity-Drops-OnDeath'
- inject s@dRegions_Flag_Entity-Drops-OnDeath p:event-global
}
- queue clear
}
- define regionPri 'li@'
- foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Entity-Drops-OnDeath'
- inject s@dRegions_Flag_Entity-Drops-OnDeath p:event
on entity spawns:
- define world '<c.entity.world.name>'
- define target '<c.entity.entity_type>'
- if <c.entity.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.mob-spawn.%target%]||null>'
- if %cache% == false {
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Mob-Spawn'
- inject s@dRegions_Flag_Mob-Spawn p:event-global
}
- queue clear
}
- define regionPri 'li@'
- foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Mob-Spawn'
- inject s@dRegions_Flag_Mob-Spawn p:event
on entity enters portal:
- define world '<c.location.world.name.to_lowercase>'
- define readPath 'portal.<tern[<c.entity.is_player>]:player||entity>-enter'
- inject s@dRegions p:event_PreProc_Config-NoTarget
on entity changes soil:
- define world '<c.location.world.name>'
- define type '<c.entity.prefix>'
- define readPath 'trample-crops.%type%'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.trample-crops-%type%]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Trample-Crops-%type%'
- inject %FlagScript% p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Trample-Crops-%type%'
- inject %FlagScript% p:event
on falling_block changes block:
- define mat '<c.entity.fallingblock_material.bukkit_enum>'
- if li@sand|gravel !contains %mat% queue clear
- define world '<c.location.world.name>'
- define readPath 'physics.%mat%'
- define FlagScript 's@dRegions_Flag_Falling-%mat%'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.falling-%mat%]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Falling-%mat%'
- inject %FlagScript% p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Falling-%mat%'
- inject %FlagScript% p:event
on entity changes block:
- if <c.old_material.bukkit_enum> == soil || li@falling_block|creeper|primed_tnt contains <c.entity.entity_type> {
- queue clear
}
- define world '<c.location.world.name>'
- define readPath 'entity.changeBlock'
- define target '<c.entity.entity_type>'
- inject s@dRegions p:event_PreProc_Config
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.entity-grief.%target%]||null>'
- if %cache% == false {
# - run s@dRegions_Flag_Entity-Grief offthread delay:1t def:<c.entity.uuid>
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Entity-Grief'
- inject s@dRegions_Flag_Entity-Grief p:event-global
}
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Entity-Grief'
- inject s@dRegions_Flag_Entity-Grief p:event
on entity forms block:
# - if <c.entity.has_flag[dRegions_NoGrief]> determine cancelled
- if <server.has_flag[dRegions.EntityGrief.<c.entity.uuid>]> {
- determine cancelled
}
- define world '<c.location.world.name>'
- define readPath 'entity.changeBlock'
- define target '<c.entity.entity_type||other>'
- inject s@dRegions p:event_PreProc_Config
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.entity-grief.%target%]||null>'
- if %cache% == false {
- run s@dRegions_Flag_Entity-Grief offthread delay:1t def:<c.entity.uuid>
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Entity-Grief'
- inject s@dRegions_Flag_Entity-Grief p:event-global
}
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Entity-Grief'
- inject s@dRegions_Flag_Entity-Grief p:event
on entity explodes:
- define world '<c.location.world.name>'
- define readPath 'entity.explode'
- define attacker '<c.entity>'
- define target '<c.entity.entity_type>'
- inject s@dRegions p:event_PreProc_Config
- if <c.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.entity-explode.%target%]||null>'
- if %cache% == false {
- determine cancelled
}
- if %cache% == null {
- define FlagScript 's@dRegions_Flag_Entity-Explode'
- inject s@dRegions_Flag_Entity-Explode p:event-global
}
- queue clear
}
- define regionPri 'li@'
- foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Entity-Explode'
- inject s@dRegions_Flag_Entity-Explode p:event
on entity breaks hanging:
- if <c.entity.prefix> == player {
- queue clear
}
- define world '<c.entity.world.name>'
- define type '<c.hanging.entity_type.replace[_]>'
- define readPath 'entity-break-%type%'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- if <c.hanging.location.cuboids.is_empty||true> {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.entity-break-%type%]||null>'
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define FlagScript 's@dRegions_Flag_Entity-Break-%type%'
- inject %FlagScript% p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.hanging.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Entity-Break-%type%'
- inject %FlagScript% p:event
on player breaks hanging:
- if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
- define world '<c.entity.world.name>'
- if <c.hanging.location.cuboids.is_empty||true> {
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event-global
- define FlagScript 's@dRegions_Flag_Hanging-Break'
- inject s@dRegions_Flag_Hanging-Break p:event-global
- queue clear
}
- define regionPri 'li@'
- foreach <c.hanging.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- define FlagScript 's@dRegions_Flag_Build'
- inject s@dRegions_Flag_Build p:event
- define FlagScript 's@dRegions_Flag_Hanging-Break'
- inject s@dRegions_Flag_Hanging-Break p:event
#
# END Mob Events
##################################################
#
# Utility Subscripts
#
testinga:
- ^define world '<player.location.world.name.to_lowercase>'
- define regionPri 'li@'
- foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]]>|__global__ {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- ^narrate %orderedRegions%
testingb:
- ^define world '<player.location.world.name.to_lowercase>'
- define regionPri 'li@'
- foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- foreach <server.flag[dRegions_FlagMap].filter[contains_any[regionEnter|regionToggle]].parse[after[/]].alphanumeric.parse[split[/].get[2]]> {
- define FlagScript '%value%'
}
testingc:
- if ( a == a ) && ( b == b ) && ( c == d ) {
- narrate "true"
}
else {
- narrate "false"
}
start:
- inject locally loadYaml
- define flags '<server.list_flags.filter[starts_with[dRegions]]>'
- foreach %flags% {
- flag server %value%:!
}
- define flagScripts '<server.list_scripts.filter[starts_with[s@dRegions_Flag_]]||li@>'
- flag server 'dRegions_Flags:!'
- flag server 'dRegions_Flags:|:%flagScripts%'
# - define flagMap 'li@'
# - foreach '%flagScripts%' {
# - define flagMap '<def[flagMap].include[<def[value].yaml_key[event_hook]||none>/<def[value].yaml_key[event_priority]||none>]>/%value%'
# }
- flag server 'dRegions_FlagMap:!'
# - flag server 'dRegions_FlagMap:|:%flagMap%'
event_PreProc_Config:
# Reusable code block injected from events.
# This pre-processor handles events in the global and world config files before
# any regions even get a chance. World configs are processed before global.
# This way worlds can deny events that global allows, but global has ultimate
# control for denying events. Denying an event takes precedence over allowing.
# Default is 'true' on most events for this reason.
#
# Events that take a block list are handled here as well. Blocklists can
# operate in whitelist or blacklist modes.
#
# Blacklist mode.
# When an event is set to 'false' and no blocks are specified in the
# blocklist, it will always cancel the event. If there are blocks specified,
# it will only cancel events involving those blocks listed.
#
# Whitelist mode.
# When an event is set to 'true' and no blocks are specified in the blocklist,
# it will always allow the event. If there are blocks specifed, it will only
# allow events involving those blocks listed.
#
- define targetList '<yaml[dRegions_%world%_config].read[config.%readPath%-list]||li@>'
- if <yaml[dRegions_%world%_config].read[config.%readPath%]||true> {
- if !<def[targetList].is_empty> && %targetList% !contains %target% {
- determine cancelled
}
}
else {
- if <def[targetList].is_empty> || %targetList% contains %target% {
- determine cancelled
}
}
- define targetList '<yaml[dRegions_global_config].read[config.%readPath%-list]||li@>'
- if <yaml[dRegions_global_config].read[config.%readPath%]||true> {
- if !<def[targetList].is_empty> && %targetList% !contains %target% {
- determine cancelled
}
}
else {
- if <def[targetList].is_empty> || %targetList% contains %target% {
- determine cancelled
}
}
event_PreProc_Config-NoTarget:
- if !<yaml[dRegions_%world%_config].read[config.%readPath%]> {
- determine cancelled
}
- if !<yaml[dRegions_global_config].read[config.%readPath%]> {
- determine cancelled
}
loadYaml:
# Reloads the yaml files and generates default files if they don't exist.
# Rewrites config files that do not match internal version number!
- announce "<&b>dRegions<&co><&3> Loading system config files..." to_console
- define world 'global'
- define file 'config'
- if !<server.has_file[dRegions/config.yml]> {
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally createConfigFile instantly
- flag <player> ConfigFileGeneratorNotify:!
- run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> config file!'
}
else {
- inject locally createConfigFile
}
- announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> config file!" to_console
}
- if <yaml.list.contains[dRegions_global_config]> {
- yaml unload 'id:dRegions_global_config'
}
- yaml 'load:dRegions/config.yml' 'id:dRegions_global_config'
- if <yaml[dRegions_<def[world]>_config].read[config.version].is[!=].to[<s@dRegions_Configurations.yaml_key[config.version]>]||false> {
- define isUpdate ''
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally createConfigFile
- flag <player> ConfigFileGeneratorNotify:!
- run s@dRegions_Msg 'def:<&7><&o>Updated <&f><&o>%world%<&7><&o> config file!'
}
else {
- inject locally createConfigFile
}
- define isUpdate:!
- announce "<&b>dRegions<&co> <&7><&o>Updated <&f><&o>%world%<&7><&o> config file!" to_console
}
- foreach <server.list_worlds.parse[name.to_lowercase]> {
- define world '<def[value]>'
- define file 'worlds/%world%/config'
- if !<server.has_file[dRegions/%file%.yml]> {
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally createConfigFile
- flag <player> ConfigFileGeneratorNotify:!
- run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> config file!'
}
else {
- inject locally createConfigFile
}
- announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> config file!" to_console
}
- if <yaml.list.contains[dRegions_%world%_config]> {
- yaml unload 'id:dRegions_%world%_config'
}
- yaml 'load:dRegions/%file%.yml' 'id:dRegions_%world%_config'
- if <yaml[dRegions_<def[world]>_config].read[config.version].is[!=].to[<s@dRegions_Configurations.yaml_key[config.version]>]||false> {
- define isUpdate ''
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally createConfigFile
- flag <player> ConfigFileGeneratorNotify:!
- run s@dRegions_Msg 'def:<&7><&o>Updated <&f><&o>%world%<&7><&o> config file!'
}
else {
- inject locally createConfigFile
}
- define isUpdate:!
- announce "<&b>dRegions<&co> <&7><&o>Updated <&f><&o>%world%<&7><&o> config file!" to_console
}
- define file 'worlds/%world%/regions'
- if !<server.has_file[dRegions/%file%.yml]> {
- define region '__global__'
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally createRegionFile
- flag <player> ConfigFileGeneratorNotify:!
- run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> regions file!'
}
else {
- inject locally createRegionFile
}
- announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> regions file!" to_console
}
- if <yaml.list.contains[dRegions_%world%_regions]> {
- yaml unload 'id:dRegions_%world%_regions'
}
- yaml 'load:dRegions/%file%.yml' 'id:dRegions_%world%_regions'
- define file 'worlds/%world%/inventories'
- if !<server.has_file[dRegions/%file%.yml]> {
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally createInventoryFile
- flag <player> ConfigFileGeneratorNotify:!
- run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> regions file!'
}
else {
- inject locally createInventoryFile
}
- announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> inventory file!" to_console
}
- if <yaml.list.contains[dRegions_%world%_inventories]> {
- yaml unload 'id:dRegions_%world%_inventories'
}
- yaml 'load:dRegions/%file%.yml' 'id:dRegions_%world%_inventories'
- define file 'worlds/%world%/cache'
- if !<server.has_file[dRegions/%file%.yml]> {
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally createCacheFile
- flag <player> ConfigFileGeneratorNotify:!
- run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> cache file!'
}
else {
- inject locally createCacheFile
}
- announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> cache file!" to_console
}
- if <yaml.list.contains[dRegions_%world%_cache]> {
- yaml unload 'id:dRegions_%world%_cache'
}
- yaml 'load:dRegions/%file%.yml' 'id:dRegions_%world%_cache'
}
- announce "<&b>dRegions<&co><&a> System config files Loaded!" to_console
reloadYaml:
# A simpler reload
- announce "<&b>dRegions<&co><&3> Reloading system config files..." to_console
- run s@dRegions_Msg 'def:<&7><&o>Reloading system config files...'
- if <yaml.list.contains[dRegions_global_config]> {
- yaml unload 'id:dRegions_global_config'
}
- yaml 'load:dRegions/config.yml' 'id:dRegions_global_config'
- foreach <server.list_worlds.parse[name.to_lowercase]> {
- define world '<def[value]>'
- if <yaml.list.contains[dRegions_%world%_config]> {
- yaml unload 'id:dRegions_%world%_config'
}
- yaml 'load:dRegions/worlds/%world%/config.yml' 'id:dRegions_%world%_config'
- if <yaml.list.contains[dRegions_%world%_regions]> {
- yaml unload 'id:dRegions_%world%_regions'
}
- yaml 'load:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- if <yaml.list.contains[dRegions_%world%_inventories]> {
- yaml unload 'id:dRegions_%world%_inventories'
}
- yaml 'load:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- if <yaml.list.contains[dRegions_%world%_cache]> {
- yaml unload 'id:dRegions_%world%_cache'
}
- yaml 'load:dRegions/worlds/%world%/cache.yml' 'id:dRegions_%world%_cache'
}
- announce "<&b>dRegions<&co><&a> System config files Loaded!" to_console
- run s@dRegions_Msg 'def:<&7><&o>System config files Loaded!'
createConfigFile:
- define readID 'dRegions_Configurations'
- define writeID 'dRegions_%world%_config'
- if !<yaml.list.contains[%readID%]> {
- yaml fix_formatting 'load:<script.relative_filename>' 'id:%readID%'
}
- if !<yaml.list.contains[%readID%]> {
- announce to_console "Loaded <script.relative_filename>"
}
- yaml create 'id:%writeID%'
- define readPath '%readID%.config'
- define writePath 'config'
- if <def[isUpdate].exists||false> {
- run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|true instantly
}
else {
- run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
}
- yaml unload 'id:%readID%'
- yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
createRegionFile:
- define readID 'dRegions_Configurations'
- define writeID 'dRegions_%world%_regions'
- if !<yaml.list.contains[%readID%]> {
- yaml fix_formatting 'load:<script.relative_filename>' 'id:%readID%'
}
- yaml create 'id:%writeID%'
- define readPath '%readID%.regions.__global__'
- define writePath 'regions.%region%'
- run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
- yaml unload 'id:%readID%'
- yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
createInventoryFile:
- define readID 'dRegions_Configurations'
- define writeID 'dRegions_%world%_inventories'
- if !<yaml.list.contains[%readID%]> {
- yaml fix_formatting 'load:<script.relative_filename>' 'id:%readID%'
}
- yaml create 'id:%writeID%'
- define readPath '%readID%.inventories'
- define writePath 'inventories'
- run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
- yaml unload 'id:%readID%'
- yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
createCacheFile:
- define readID 'dRegions_Configurations'
- define writeID 'dRegions_%world%_cache'
- if !<yaml.list.contains[%readID%]> {
- yaml fix_formatting 'load:<script.relative_filename>' 'id:%readID%'
}
- yaml create 'id:%writeID%'
- define readPath '%readID%.cache'
- define writePath 'cache'
- run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
- yaml unload 'id:%readID%'
- yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
createRegionEntry:
- if !<yaml.list.contains[dRegions_%world%_regions]> {
yaml 'load:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
}
- yaml set 'regions.%name%.type:cuboid' 'id:dRegions_%world%_regions'
- yaml set 'regions.%name%.min:<def[selectedCuboid].min.simple>' 'id:dRegions_%world%_regions'
- yaml set 'regions.%name%.max:<def[selectedCuboid].max.simple>' 'id:dRegions_%world%_regions'
- yaml set 'regions.%name%.priority:0' 'id:dRegions_%world%_regions'
- yaml set 'regions.%name%.flags:|:' 'id:dRegions_%world%_regions'
- yaml set 'regions.%name%.owners:|:' 'id:dRegions_%world%_regions'
- foreach <def[ownerGroups]||li@> {
- yaml set 'regions.%name%.owners.groups:->:%value%' 'id:dRegions_%world%_regions'
}
- foreach <def[ownerPlayers]||li@> {
- yaml set 'regions.%name%.owners.players:->:%value%' 'id:dRegions_%world%_regions'
}
- yaml set 'regions.%name%.members:|:' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- note cu@<def[selectedCuboid].min.simple>|<def[selectedCuboid].max.simple> 'as:dregions_%world%_%name%'
clearCache:
- define region %1%
- define world %2%
- define flag %3%
- define type '<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
- if %type% == list {
- define type '<s@dRegions_Flag_%flag%.yaml_key[flag_parent].as_script.yaml_key[flag_type]>'
}
- if %region% == '__global__' {
- inject locally clearCacheGlobal
- queue clear
}
- define cuboid '<cu@dregions_%world%_%region%.as_cuboid>'
- define children '<yaml[dRegions_%world%_regions].read[regions.%region%.children]||li@>'
- define overlaps '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].parse[replace[regex:^].with[cu@dregions_%world%_]].filter[as_cuboid.is[!=].to[null]].filter[intersects[%cuboid%]].parse[replace[cu@dregions_%world%_]]||li@>'
- if li@boolean|state-withTarget contains %type% {
- yaml set 'cache.%type%.%region%.%flag%:!' 'id:dRegions_%world%_cache'
- foreach <def[children].include[%overlaps%].include[__global__]> {
- yaml set 'cache.%type%.%value%.%flag%:!' 'id:dRegions_%world%_cache'
}
}
else if li@state-withGroup|state-withTarget-withGroup|state-withTargetString-withGroup contains %type% {
- define players '<def[cuboid].list_players>'
- foreach %players% {
- flag <player> dRegions.cache.%world%.%region%.%flag%:!
}
}
clearCacheGlobal:
- define allRegions '<yaml[dRegions_%world%_regions].list_keys[regions]||li@>'
- if li@boolean|state-withTarget contains %type% {
- foreach %allRegions% {
- yaml set 'cache.%type%.%value%.%flag%:!' 'id:dRegions_%world%_cache'
}
}
else if li@state-withGroup|state-withTarget-withGroup|state-withTargetString-withGroup contains %type% {
- foreach <server.list_online_players> {
- flag <player> dRegions.cache.%world%.%region%.%flag%:!
}
}
#
# END Utility Subscripts
##################################################
#
# Message format
#
dRegions_Msg:
type: item
speed: 0
debug: false
material: i@human_skull
display name: "<&4> [<&6>dRegions<&4>]"
lore:
- <&5>Click for Help
script:
- ^define text '<&4>[<&6>dRegions<&4>]'
- ^define hover '<&chr[007B]><i@dRegions_Msg.json><&chr[007D]>'
- ^define click '/dregions help'
- ^define button "text:'%text%',clickEvent:<&chr[007B]>action:run_command,value:'%click%'<&chr[007D]>,hoverEvent:<&chr[007B]>action:show_item,value:'%hover%'<&chr[007d]>"
- ^define spacer "text:' '"
- ^define msg "text:'%1%'"
- ^if <player.is_player||false> {
- execute as_server "tellraw <player.name> <&chr[007B]>text:'',extra:[<&chr[007B]>%button%<&chr[007D]>,<&chr[007B]>%spacer%<&chr[007D]>,<&chr[007B]>%msg%<&chr[007D]>]<&chr[007D]>"
}
else {
- announce to_console "%1%"
}
################################################################################
#
# dRegions Command Script Container
#
# This script covers all dRegions commands
#
#
#
#--------------------------------------
#
# dRegions Command Script Basics
#
# The basic stuff required in a command script container
#
dRegions_Commands:
type: command
speed: 0
debug: false
name: dregions
description: Denizen Regions Manager
usage: /dregions
aliases:
- drg
allowed help:
- determine true
commandArgs:
help:
usage: '/drg help <<>arg/<&ns><>>'
permissions: []
about:
usage: '/drg about'
permissions: []
reload:
usage: '/drg reload'
permissions: []
restart:
usage: '/drg restart'
permissions: []
define:
usage: '/drg define [ID] (g:group) (player)'
permissions: []
redefine:
usage: '/drg redefine [ID]'
permissions: []
claim:
usage: '/drg claim [ID]'
permissions: []
select:
usage: '/drg select [ID] -w world'
permissions: []
info:
usage: '/drg info [ID] -w world'
permissions: []
addowner:
usage: '/drg addowner [ID] g:group player -w world'
permissions: []
removeowner:
usage: '/drg removeowner [ID] g:group player -w world'
permissions: []
addmember:
usage: '/drg addmember [ID] g:group player -w world'
permissions: []
removemember:
usage: '/drg removemember [ID] g:group player -w world'
permissions: []
list:
usage: '/drg list (page<&ns>) -h -r region -w world -p player'
permissions: []
flag:
usage: '/drg flag [ID] [flag] [value] -g group -w world'
permissions: []
setpriority:
usage: '/drg setpriority [ID] [<&ns>]'
permissions: []
setparent:
usage: '/drg setparent [ID] [parent]'
permissions: []
teleport:
usage: '/drg teleport [ID] -w world'
permissions: []
remove:
usage: '/drg remove [ID] -w world'
permissions: []
tab complete:
- define args '<script.list_keys[commandArgs].alphanumeric.to_lowercase||li@>'
- define arg '<c.args.get[1]||null>'
- if <def[arg].is[==].to[null]>
|| !<def[args].contains[%arg%]> {
- inject locally tab_arg_1
}
else {
- inject locally tab_%arg%
}
- determine '<def[result]||li@>'
script:
- define command '<c.args.get[1].escaped||help>'
- define args '<script.list_keys[commandArgs].alphanumeric.to_lowercase||li@>'
- if !<def[args].contains[%command%]> {
- inject locally help
}
else {
- inject locally %command%
}
#
# END dRegions Command Script Basics
#--------------------------------------
#
# dRegions Command TAB Completion
#
# Each of these subscripts handles TAB completion for the positional argument.
#
#
tab_arg_1:
# This Excludes args from the original args
- foreach %args% {
- if !<player.has_permission[dregions.%value%]||<player.is_op||false>> {
- define args '<def[args].exclude[%value%]||%args%>'
}
}
- if <def[args].is_empty||true> {
- define result 'li@'
}
else {
- define result '<def[args].filter[starts_with[%arg%]]||li@> '
- if <def[result].is_empty||true> {
- define result '%args%'
}
}
tab_help:
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- if <def[spaces].is[==].to[0]> {
- define result 'help [command]'
}
else if <def[spaces].is[==].to[1]> {
- define result 'li@'
- foreach %args% {
- if <player.has_permission[dregions.%value%]||<player.is_op||false>> {
- define result '<def[result].include[%value%]||%result%>'
}
else {
- foreach next
}
}
- if <c.args.get[2].is[!=].to[null]||false> {
- define result '<def[args].filter[starts_with[<c.args.get[2]>]]||li@>'
- if <def[result].is_empty> {
- foreach %args% {
- if <player.has_permission[dregions.%value%]||<player.is_op||false>> {
- define result '<def[result].include[%value%]||%result%>'
}
else {
- foreach next
}
}
}
}
}
tab_about:
- define result 'li@'
tab_reload:
- define result 'li@'
tab_restart:
- define result 'li@'
tab_define:
# /drg define [ID] (g:group) (player)
- if <player.has_permission[dregions.define]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- if <def[spaces].is[==].to[0]> {
- define result 'define [ID]'
}
else if <def[spaces].is[==].to[1]> {
- if <c.args.get[2].is[==].to[null]||true> {
- define result '[ID] (g:group) (player)'
}
else {
- define result '<c.args.get[2]> (g:group) (player)'
}
}
else if <def[spaces].is[OR_MORE].than[2]> {
- define owners '<c.args.remove[1|2]||li@>'
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define owners '<def[owners].remove[<def[owners].find[-w]>|<def[owners].find[-w].add[1].as_int>]||li@>'
}
- define owner '<def[owners].last||li@>'
- if <def[owner].starts_with[g:]||false> {
- define group '<def[owner].replace[g:]>'
- define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
- if <def[groups].is_empty> {
- define groups '<server.list_permission_groups||li@>'
}
- define result '<def[groups].parse[replace[regex:^].with[g:]]>'
}
else {
- define result '<server.match_player[%owner%].name||null>'
- if <def[result].is[==].to[null]||true> {
- define result '<server.list_online_players.parse[name]>'
}
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_redefine:
# /drg redefine [ID]
- if <player.has_permission[dregions.redefine]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||true>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- if <def[spaces].is[==].to[0]> {
- define result '<def[regions].parse[replace[regex:^].with[redefine ]]>'
}
else if <def[spaces].is[==].to[1]> {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_claim:
- if <player.has_permission[dregions.claim]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- if <def[spaces].is[==].to[0]> {
- define result '<def[regions].parse[replace[regex:^].with[claim ]]>'
}
else if <def[spaces].is[==].to[1]> {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_select:
# /drg select [ID] -w world
- if <player.has_permission[dregions.select]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- if <def[spaces].is[==].to[0]> {
- define result '<def[regions].parse[replace[regex:^].with[select ]]>'
}
else if <def[spaces].is[==].to[1]> {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped||null>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_info:
# /drg info [ID] -w world
- if <player.has_permission[dregions.info]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- if <def[spaces].is[==].to[0]> {
- define result '<def[regions].parse[replace[regex:^].with[info ]]>'
}
else if <def[spaces].is[==].to[1]> {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped||null>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_addowner:
# /drg addowner [ID] g:group player -w world
- if <player.has_permission[dregions.addowner]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- if <def[spaces].is[==].to[0]> {
- define result '<def[regions].parse[replace[regex:^].with[addowner ]]>'
}
else if <def[spaces].is[==].to[1]> {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped||null>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else if <def[spaces].is[OR_MORE].than[2]> {
- define owners '<c.args.remove[1|2]||li@>'
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define owners '<def[owners].remove[<def[owners].find[-w]>|<def[owners].find[-w].add[1].as_int>]||li@>'
}
- define owner '<def[owners].last||li@>'
- if <def[owner].starts_with[g:]||false> {
- define group '<def[owner].replace[g:]>'
- define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
- if <def[groups].is_empty> {
- define groups '<server.list_permission_groups.alphanumeric||li@>'
}
- define result '<def[groups].parse[replace[regex:^].with[g:]]>'
}
else {
- define result '<server.match_player[%owner%].name||null>'
- if <def[result].is[==].to[null]||true> {
- define result '<server.list_online_players.parse[name].alphanumeric>'
}
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_removeowner:
# /drg removeowner [ID] g:group player -w world
- if <player.has_permission[dregions.removeowner]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- if <def[spaces].is[==].to[0]> {
- define result '<def[regions].parse[replace[regex:^].with[removeowner ]]>'
}
else if <def[spaces].is[==].to[1]> {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else if <def[spaces].is[OR_MORE].than[2]> {
- define owners '<c.args.remove[1|2]||li@>'
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define owners '<def[owners].remove[<def[owners].find[-w]>|<def[owners].find[-w].add[1].as_int>]||li@>'
}
- define owner '<def[owners].last||li@>'
- if <def[owner].starts_with[g:]||false> {
- define group '<def[owner].replace[g:]>'
- define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
- if <def[groups].is_empty> {
- define groups '<server.list_permission_groups.alphanumeric||li@>'
}
- define result '<def[groups].parse[replace[regex:^].with[g:]]>'
}
else {
- define result '<server.match_player[%owner%].name||null>'
- if <def[result].is[==].to[null]||true> {
- define result '<server.list_online_players.parse[name].alphanumeric>'
}
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_addmember:
# /drg addmember [ID] g:group player -w world
- if <player.has_permission[dregions.addmember]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- if <def[spaces].is[==].to[0]> {
- define result '<def[regions].parse[replace[regex:^].with[addmember ]]>'
}
else if <def[spaces].is[==].to[1]> {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else if <def[spaces].is[OR_MORE].than[2]> {
- define members '<c.args.remove[1|2]||li@>'
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define members '<def[members].remove[<def[members].find[-w]>|<def[members].find[-w].add[1].as_int>]||li@>'
}
- define member '<def[members].last||li@>'
- if <def[member].starts_with[g:]||false> {
- define group '<def[member].replace[g:]>'
- define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
- if <def[groups].is_empty> {
- define groups '<server.list_permission_groups.alphanumeric||li@>'
}
- define result '<def[groups].parse[replace[regex:^].with[g:]]>'
}
else {
- define result '<server.match_player[%owner%].name||null>'
- if <def[result].is[==].to[null]||true> {
- define result '<server.list_online_players.parse[name].alphanumeric>'
}
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_removemember:
# /drg removemember [ID] g:group player -w world
- if <player.has_permission[dregions.removemember]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- if <def[spaces].is[==].to[0]> {
- define result '<def[regions].parse[replace[regex:^].with[removemember ]]>'
}
else if <def[spaces].is[==].to[1]> {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else if <def[spaces].is[OR_MORE].than[2]> {
- define members '<c.args.remove[1|2]||li@>'
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define members '<def[members].remove[<def[members].find[-w]>|<def[members].find[-w].add[1].as_int>]||li@>'
}
- define member '<def[members].last||li@>'
- if <def[member].starts_with[g:]||false> {
- define group '<def[member].replace[g:]>'
- define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
- if <def[groups].is_empty> {
- define groups '<server.list_permission_groups.alphanumeric||li@>'
}
- define result '<def[groups].parse[replace[regex:^].with[g:]]>'
}
else {
- define result '<server.match_player[%owner%].name||null>'
- if <def[result].is[==].to[null]||true> {
- define result '<server.list_online_players.parse[name].alphanumeric>'
}
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_list:
- define result 'li@'
tab_flag:
# TODO
# /drg flag [ID] [flag] [value] -g group -w world
- if <player.has_permission[dregions.flag]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- if <def[spaces].is[==].to[0]> {
- define result 'flag [ID]'
}
else if <def[spaces].is[==].to[1]> {
- if <c.args.get[2].is[==].to[null]||true> {
- define result '[ID]'
}
else if <c.args.get[2].is[==].to[-w]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]>'
}
else if <context.server.not> {
- define regions '<yaml[dRegions_<player.world.name.to_lowercase>_regions].list_keys[regions].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|<player.world.name.to_lowercase>|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else {
- define result 'li@'
}
}
else if <def[spaces].is[==].to[2]> {
- if <c.args.get[2].is[==].to[-w]||false> {
- if <c.args.get[3].is[!=].to[null]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
}
else if <c.args.get[2].is[!=].to[null]||false> {
- define allFlags '<server.flag[dRegions_Flags].parse[name.split[_].get[3].to_lowercase].alphanumeric||li@>'
- if <c.args.get[3].is[==].to[-w]||false> {
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- if <c.args.get[3].is[!=].to[null]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]||li@>'
}
}
else if <c.args.get[3].is[!=].to[null]||false> {
- define result '<def[allFlags].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '<def[allFlags]||li@>'
}
}
else {
- if <def[result].is_empty||true> {
- define result '<def[allFlags]||li@>'
}
}
}
}
else if <def[spaces].is[==].to[3]> {
- if <c.args.get[2].is[==].to[-w]||false> {
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].alphanumeric||li@>'
- if <c.args.get[4].is[!=].to[null]||false> {
- define result '<def[regions].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<def[regions]||li@>'
}
}
else if <c.args.get[3].is[==].to[-w]||false> {
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- if <c.args.get[4].is[!=].to[null]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]].parse[replace[regex:^].with[-w ]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
}
else if <c.args.get[4].is[==].to[-w]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]||li@>'
}
}
else if <def[spaces].is[==].to[4]> {
- if <c.args.get[4].is[==].to[-w]||false> {
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].alphanumeric||li@>'
- if <c.args.get[5].is[!=].to[null]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[5].escaped>]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
}
else {
- define allFlags '<server.flag[dRegions_Flags].parse[name.split[_].get[3].to_lowercase].alphanumeric||li@>'
- if <c.args.get[5].is[!=].to[null]||false> {
- define result '<def[allFlags].filter[starts_with[<c.args.get[5].escaped>]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<def[allFlags]||li@>'
}
}
}
}
else {
- define result 'li@'
}
tab_setpriority:
# /drg remove [ID] -w world
- if <player.has_permission[dregions.setpriority]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- if <def[spaces].is[==].to[0]> {
- define result 'setpriority [ID]'
}
else if <def[spaces].is[==].to[1]> {
- if <c.args.get[2].is[==].to[null]||true> {
- define result '[ID]'
}
else if <c.args.get[2].is[==].to[-w]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]>'
}
else if <context.server.not> {
- define regions '<yaml[dRegions_<player.world.name.to_lowercase>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|<player.world.name.to_lowercase>|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
}
else {
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||%regions%>'
- if <def[result].is_empty> {
- define result '%regions%'
}
}
}
else {
- define result 'li@'
}
}
else if <def[spaces].is[==].to[2]> {
- if <c.args.get[2].is[==].to[-w]||false> {
- if <c.args.get[3].is[!=].to[null]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
}
else {
- if <c.args.get[3].is[MATCHES].to[number]> {
- define result '<c.args.get[3]>'
}
else if <c.args.get[3].is[==].to[-w]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]||li@>'
}
else {
- define result '<&ns>'
}
}
}
else if <def[spaces].is[==].to[3]> {
- if <c.args.get[2].is[==].to[-w]||false> {
- if <c.args.get[4].is[!=].to[null]||false> {
- define regions '<yaml[dRegions_<c.args.get[3].escaped>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- define result '<def[regions].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else {
- define result '<yaml[dRegions_<c.args.get[3].escaped>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
}
}
else if <c.args.get[3].is[==].to[-w]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
else {
- if <c.args.get[4].is[!=].to[null]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
}
else {
- define result '<server.list_worlds.parse[name].parse[replace[regex:^].with[-w ]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]||li@>'
}
}
}
else if <def[spaces].is[==].to[4]> {
- if <c.args.get[2].is[==].to[-w]||false>
|| <c.args.get[3].is[==].to[-w]||false> {
- if <c.args.get[5].is[MATCHES].to[number]> {
- define result '<c.args.get[5]>'
}
else {
- define result '<&ns>'
}
}
else if <c.args.get[4].is[==].to[-w]> {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
tab_setparent:
# TODO
- define result 'li@'
tab_teleport:
# TODO
- define result 'li@'
tab_remove:
# /drg remove [ID] -w world
- if <player.has_permission[dregions.remove]||<player.is_op||false>> {
- define spaces '<c.raw_args.to_list.count[ ]||0>'
- if <def[spaces].is[==].to[0]> {
- define result 'remove [ID] -w world'
}
else if <def[spaces].is[==].to[1]> {
- if <c.args.get[2].is[==].to[null]||true> {
- define result '[ID]'
}
else if <c.args.get[2].is[==].to[-w]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]>'
}
else if <context.server.not> {
- define regions '<yaml[dRegions_<player.world.name.to_lowercase>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- foreach %regions% {
- if <proc[dRegions_IsOwner].context[%value%|<player.world.name.to_lowercase>|<player>].not> {
- define regions '<def[regions].exclude[%value%]||%regions%>'
}
}
}
- define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else {
- define result 'li@'
}
}
else if <def[spaces].is[==].to[2]> {
- if <c.args.get[2].is[==].to[-w]||false> {
- if <c.args.get[3].is[!=].to[null]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
}
else {
- define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]>'
}
}
else if <def[spaces].is[==].to[3]> {
- if <c.args.get[2].is[==].to[-w]||false> {
- if <c.args.get[4].is[!=].to[null]||false> {
- define regions '<yaml[dRegions_<c.args.get[3].escaped>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- define result '<def[regions].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
- if <def[result].is_empty||true> {
- define result '%regions%'
}
}
else {
- define result '<yaml[dRegions_<c.args.get[3].escaped>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
}
}
else {
- if <c.args.get[4].is[!=].to[null]||false> {
- define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
}
else {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
- if <def[result].is_empty||true> {
- define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
}
}
}
else {
- define result 'li@'
}
}
else {
- define result 'li@'
}
#
# END dRegions Command TAB Completion
#--------------------------------------
#
# dRegions Command Arguments
#
# Each of these subscripts is an argument for the root command.
#
help:
- define arg '<c.args.get[2].escaped||null>'
- if <def[args].contains[%arg%]||false> {
- run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%arg%.usage]||No help for you!>'
- queue clear
}
- if <player.has_permission[dRegions.admin]||<player.is_op||<context.server||false>>> {
- inject locally msgsHelpAdmin
}
else {
- inject locally msgsHelpUser
}
- inject locally msgsFooter
- queue clear
about:
- inject locally msgsHelpUser
- inject locally msgsFooter
- queue clear
reload:
- if !<player.has_permission[dRegions.reload]||<player.is_op||<context.server||false>>> {
- inject locally help
- queue clear
}
- inject s@dRegions p:reloadYaml instantly
# - run s@dRegions_Msg 'def:<&7><&o>System files loaded!'
restart:
- if !<player.has_permission[dRegions.restart]||<player.is_op||<context.server||false>>> {
- inject locally help
- queue clear
}
- run s@dRegions p:start instantly
define:
# /drg define [ID] (g:group) (player)
- inject locally prerun instantly
# Check for existing region
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]||true>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists]> {
- run s@dRegions_Msg 'def:<&c>There is already a region by this name!'
- queue clear
}
# Check for overlapping regions
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|%world%|<player>]> {
- run s@dRegions_Msg 'def:<&c>Region selection contains unowned regions!'
- queue clear
}
}
# Parse any declared owners
- define owners '<c.args.remove[1|2].replace[:].with[;]||li@>'
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define owners '<def[owners].remove[<def[owners].find[-w]>|<def[owners].find[-w].add[1].as_int>]||li@>'
}
- define ownerGroups li@
- define ownerPlayers li@
- foreach %owners% {
- if <def[value].starts_with[g;]||false> {
- define ownerGroups '<def[ownerGroups].include[<def[value].replace[g;]>]||%ownerGroups%>'
}
else {
- if !<def[value].as_player.is[!=].to[null]||false> {
- foreach next
}
- define ownerPlayers '<def[ownerPlayers].include[<def[value].as_player.uuid>]||%ownerPlayers%>'
}
}
# Automatically add the player that defined the region as the owner
- if <yaml[dregions_global_config].read[config.regions.ownerOnDefine].is[==].to[true]||false> {
- if <def[ownerPlayers].contains[<player.uuid>].not||false> {
- define ownerPlayers '<def[ownerPlayers].include[<player.uuid>]||%ownerPlayers%>'
}
}
# Create the region
- inject s@dRegions p:createRegionEntry instantly
- run s@dRegions_Msg 'def:<&7><&o>Created %name% in %world%'
redefine:
# /drg redefine [ID]
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Don't redefine global type regions
- if <yaml[dRegions_%world%_regions].read[regions.%name%.type].is[==].to[global]||false> {
- run s@dRegions_Msg 'def:<&c>You can not redefine global regions!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Check for overlapping regions
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|%world%|<player>]> {
- run s@dRegions_Msg 'def:<&c>Region selection contains unowned regions!'
- queue clear
}
}
# Update the region
- yaml set 'regions.%name%.min:<def[selectedCuboid].min.simple>' 'id:dRegions_%world%_regions'
- yaml set 'regions.%name%.max:<def[selectedCuboid].max.simple>' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- note cu@<def[selectedCuboid].min.simple>|<def[selectedCuboid].max.simple> 'as:dregions_%world%_%name%'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> updated to selection'
claim:
# /drg claim [ID]
- inject locally prerun instantly
# Check Global region limits
- define globalRegionLimit '<yaml[dregions_global_config].read[config.regions.claim.max-region-count-per-player.default]||0>'
- if <def[globalRegionLimit].is[MORE].than[0]> {
- define playerGlobalRegions 'li@'
- foreach <server.list_worlds.parse[name.to_lowercase]> {
- define thisWorld '%value%'
- foreach '<yaml[dRegions_%thisWorld%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>' {
- define region '%value%'
- if <proc[dRegions_IsOwner].context[<def[region]>|<def[thisWorld]>|<player>]||false> {
- define playerGlobalRegions '<def[playerGlobalRegions].include[<def[region]>]||<def[playerGlobalRegions]>>'
}
}
}
- if <def[playerGlobalRegions].size.is[OR_MORE].than[%globalRegionLimit%]> {
- run s@dRegions_Msg 'def:<&c>You already have <def[playerGlobalRegions].size> total regions!'
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
}
}
# Check World region limits
- define worldRegionLimit '<yaml[dregions_%world%_config].read[config.regions.claim.max-region-count-per-player.default]||0>'
- if <def[worldRegionLimit].is[MORE].than[0]> {
- define playerWorldRegions 'li@'
- foreach '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>' {
- define region '%value%'
- if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>]||false> {
- define playerWorldRegions '<def[playerWorldRegions].include[<def[region]>]||<def[playerWorldRegions]>>'
}
}
- if <def[playerWorldRegions].size.is[OR_MORE].than[%worldRegionLimit%]> {
- run s@dRegions_Msg 'def:<&c>You already have <def[playerWorldRegions].size> regions in this world!'
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
}
}
# Check selection volume
- define globalClaimVol '<yaml[dregions_global_config].read[config.regions.claim.max-volume]||0>'
- inject s@dWE_Commands p:selection_Size instantly
- if <def[globalClaimVol].is[MORE].than[0]> {
- if <def[size].is[MORE].than[%globalClaimVol%]> {
- run s@dRegions_Msg 'def:<&c>Your selection exceeds the global limit!'
- run s@dRegions_Msg 'def:<&7><&o>Selected <&8>(<&7><&o>%size%<&8>) <&7><&o>Limit <&8>(<&7><&o>%globalClaimVol%<&8>) <&7><&o>Over <&8>(<&7><&o><def[size].sub[%globalClaimVol%].as_int><&8>)'
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
}
}
- define worldClaimVol '<yaml[dregions_%world%_config].read[config.regions.claim.max-volume]||0>'
- if <def[worldClaimVol].is[MORE].than[0]> {
- if <def[size].is[MORE].than[%worldClaimVol%]> {
- run s@dRegions_Msg 'def:<&c>Your selection exceeds the world limit!'
- run s@dRegions_Msg 'def:<&7><&o>Selected <&8>(<&7><&o>%size%<&8>) <&7><&o>Limit <&8>(<&7><&o>%worldClaimVol%<&8>) <&7><&o>Over <&8>(<&7><&o><def[size].sub[%worldClaimVol%].as_int><&8>)'
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
}
}
# Check inside existing/owned region
- if '<yaml[dregions_global_config].read[config.regions.claim.only-inside-existing-regions]||false>' {
- if <def[playerWorldRegions].exists.not> {
- define playerWorldRegions 'li@'
- foreach '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>' {
- define region '%value%'
- if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>]||false> {
- define playerWorldRegions '<def[playerWorldRegions].include[<def[region]>]||<def[playerWorldRegions]>>'
}
}
}
- define cuboids '<def[playerWorldRegions].parse[replace[regex:^].with[cu@dregions_%world%_]].filter[as_cuboid.is[!=].to[null]||false]||li@>'
- foreach %cuboids% {
- if <def[pos1].as_location.is_within[%value%]>
&& <def[pos2].as_location.is_within[%value%]> {
- define isWithin ''
- foreach stop
}
}
- if <def[isWithin].exists.not> {
- run s@dRegions_Msg 'def:<&c>You may only claim regions within land you own'
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
}
}
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists]> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
- if <yaml[dRegions_%world%_regions].read[regions.%name%.type].is[==].to[global]||false> {
- run s@dRegions_Msg 'def:<&c>You can not redefine global regions!'
- queue clear
}
- run s@dRegions_Msg 'def:<&c>Region already exists!'
- run s@dRegions_Msg 'def:<&7>You must want to update the region'
- define update ''
}
# Check for overlapping regions
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|%world%|<player>]> {
- run s@dRegions_Msg 'def:<&c>Region selection contains unowned regions!'
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
}
}
# Update the region
- if <def[update].exists||false> {
- yaml set 'regions.%name%.min:<def[selectedCuboid].min.simple>' 'id:dRegions_%world%_regions'
- yaml set 'regions.%name%.max:<def[selectedCuboid].max.simple>' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- note cu@<def[selectedCuboid].min.simple>|<def[selectedCuboid].max.simple> 'as:dregions_%world%_%name%'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> updated to selection'
}
else {
- define ownerPlayers 'li@<player.uuid>'
- inject s@dRegions p:createRegionEntry instantly
- run s@dRegions_Msg 'def:<&7><&o>Created %name% in %world%'
}
select:
# /drg select [ID]
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Don't select global type regions
- if <yaml[dRegions_%world%_regions].read[regions.%name%.type].is[==].to[global]||false> {
- run s@dRegions_Msg 'def:<&c>You can not select global regions!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
- define min '<yaml[dRegions_%world%_regions].read[regions.%name%.min].as_location.simple||null>'
- define max '<yaml[dRegions_%world%_regions].read[regions.%name%.max].as_location.simple||null>'
- flag <player> 'dWEWand_Type:cuboid'
- flag <player> dWEWand:!
- flag <player> dWEWand:|:%min%|%max%
- run s@dRegions_Msg 'def:<&7><&o>Selected <&f><&o>%name%'
info:
# /drg info [ID] -w world
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region named %name%!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
- inject locally regionInfo instantly
- define msgsHeaderTitle '<&7>Region Info<&co> <&e>%name% <&8><&lb><&7>%world%<&8><&rb>'
- inject locally msgsHeader instantly
- narrate "<&5><el@val[|].pad_right[3]><&7>Type<&co> <&f>%type% <&8><&lb><&7><&o><def[pos1].split[,].remove[4].comma_separated.replace[ ]> <&8><&pipe> <&7><&o><def[pos2].split[,].remove[4].comma_separated.replace[ ]><&8><&rb> <&lb><&7><&o>%size%<&8><&rb>"
- narrate "<&5><el@val[|].pad_right[3]><&7>Priority<&co> <&f><el@val[%priority%].pad_right[3]><&7> Parent<&co> <&f>%parent%"
- if <def[ownerPlayers].is_empty||true>
&& <def[ownerGroups].is_empty||true> {
- narrate "<&5><el@val[|].pad_right[3]><&7>Owners<&co> <&c>none"
}
else {
- define ownerList '<def[ownerPlayers].parse[as_player.name].include[<def[ownerGroups].parse[replace[regex:^].with[<&b>]]||>].comma_separated>'
- define lines '<proc[dRegions_LineWrap].context[Owners, <def[ownerList]>|45]>'
- narrate "<&5><el@val[|].pad_right[3]><&7><def[lines].get[1].split[, ].get[1]><&co> <&f><def[lines].get[1].split[, ].remove[1].comma_separated>"
- foreach <def[lines].remove[1]> {
- narrate "<&5><el@val[|].pad_right[7]><&f><def[value]>"
}
}
- if <def[memberPlayers].is_empty||true>
&& <def[memberGroups].is_empty||true> {
- narrate "<&5><el@val[|].pad_right[3]><&7>Members<&co> <&c>none"
}
else {
- define memberList '<def[memberPlayers].parse[as_player.name].include[<def[memberGroups].parse[replace[regex:^].with[<&b>]]||>].comma_separated>'
- define lines '<proc[dRegions_LineWrap].context[Members, <def[memberList]>|45]>'
- narrate "<&5><el@val[|].pad_right[3]><&7><def[lines].get[1].split[, ].get[1]><&co> <&f><def[lines].get[1].split[, ].remove[1].comma_separated>"
- foreach <def[lines].remove[1]> {
- narrate "<&5><el@val[|].pad_right[7]><&f><def[value]>"
}
}
- if <def[flags].is_empty> {
- narrate "<&5><el@val[|].pad_right[3]><&7>Flags<&co> <&c>none"
}
else {
- narrate "<&5><el@val[|].pad_right[3]><&7>Flags<&co>"
- foreach '<def[flags].alphanumeric>' {
- define flag '<def[value].split[/].get[1]>'
- define flagVal '<def[value].after[/]>'
- define flagValLength '<def[flagVal].length>'
- define lines '<proc[dRegions_LineWrap].context[%flag%, <def[flagVal]>|45]>'
- narrate "<&5><el@val[|].pad_right[5]><&e><def[lines].get[1].split[, ].get[1]><&co> <&f><def[lines].get[1].split[, ].remove[1].comma_separated>"
- foreach <def[lines].remove[1]> {
- narrate "<&5><el@val[|].pad_right[7]><&f><def[value]>"
}
}
}
- narrate "<&5>|"
- inject locally msgsFooter instantly
addowner:
# /drg addowner [ID] g:group player
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Parse specified owners
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
- define owners '<def[args].get[3].to[<def[args].size>].replace[:].with[;]||null>'
}
else {
- define owners '<c.args.get[3].to[<c.args.size>].replace[:].with[;]||null>'
}
- if <def[owners].is_empty||true> {
- run s@dRegions_Msg 'def:<&c>Must specify at least one owner'
- queue clear
}
- foreach %owners% {
- if <def[value].starts_with[g;]||false> {
- define group '<def[value].replace[g;]>'
- define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.groups]||li@>'
- if <def[groups].contains[%group%]||false> {
- run s@dRegions_Msg 'def:<&c>Group %group% is already an owner'
- foreach next
}
- define pass true
- yaml set 'regions.%name%.owners.groups:->:%group%' 'id:dRegions_%world%_regions'
}
else {
- if !<def[value].as_player.is[!=].to[null]||false> {
- foreach next
}
- define players '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.players]||li@>'
- if <def[players].contains[<def[value].as_player.uuid>]||false> {
- run s@dRegions_Msg 'def:<&c>Player %value% is already an owner'
- foreach next
}
- define pass true
- yaml set 'regions.%name%.owners.players:->:<def[value].as_player.uuid>' 'id:dRegions_%world%_regions'
}
}
- if <def[pass].exists||false> {
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> owners updated'
}
removeowner:
# /drg removeowner [ID] g:group player
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Parse specified owners
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
- define owners '<def[args].get[3].to[<def[args].size>].replace[:].with[;]||null>'
}
else {
- define owners '<c.args.get[3].to[<c.args.size>].replace[:].with[;]||null>'
}
- if <def[owners].is_empty||true> {
- run s@dRegions_Msg 'def:<&c>Must specify at least one owner'
- queue clear
}
- foreach %owners% {
- if <def[value].starts_with[g;]||false> {
- define group '<def[value].replace[g;]>'
- define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.groups]||li@>'
- if <def[groups].contains[%group%].not||true> {
- run s@dRegions_Msg 'def:<&c>Group %group% is not an owner'
- foreach next
}
- define pass true
- yaml set 'regions.%name%.owners.groups:<-:%group%' 'id:dRegions_%world%_regions'
}
else {
- if !<def[value].as_player.is[!=].to[null]||false> {
- foreach next
}
- define players '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.players]||li@>'
- if <def[players].contains[<def[value].as_player.uuid>].not||true> {
- run s@dRegions_Msg 'def:<&c>Player %value% is not an owner'
- foreach next
}
- define pass true
- yaml set 'regions.%name%.owners.players:<-:<def[value].as_player.uuid>' 'id:dRegions_%world%_regions'
}
}
- if <def[pass].exists||false> {
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> owners updated'
}
else {
- run s@dRegions_Msg 'def:<&6><&o>%name%<&c><&o> owners not updated!'
}
addmember:
# /drg addmember [ID] g:group player
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Parse specified members
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
- define members '<def[args].get[3].to[<def[args].size>].replace[:].with[;]||null>'
}
else {
- define members '<c.args.get[3].to[<c.args.size>].replace[:].with[;]||null>'
}
- if <def[members].is_empty||true> {
- run s@dRegions_Msg 'def:<&c>Must specify at least one member'
- queue clear
}
- foreach %members% {
- if <def[value].starts_with[g;]||false> {
- define group '<def[value].replace[g;]>'
- define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.members.groups]||li@>'
- if <def[groups].contains[%group%]||false> {
- run s@dRegions_Msg 'def:<&c>Group %group% is already a member'
- foreach next
}
- define pass true
- yaml set 'regions.%name%.members.groups:->:%group%' 'id:dRegions_%world%_regions'
}
else {
- if !<def[value].as_player.is[!=].to[null]||false> {
- foreach next
}
- define players '<yaml[dRegions_%world%_regions].read[regions.%name%.members.players]||li@>'
- if <def[players].contains[<def[value].as_player.uuid>]||false> {
- run s@dRegions_Msg 'def:<&c>Player %value% is already a member'
- foreach next
}
- define pass true
- yaml set 'regions.%name%.members.players:->:<def[value].as_player.uuid>' 'id:dRegions_%world%_regions'
}
}
- if <def[pass].exists||false> {
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> members updated'
}
else {
- run s@dRegions_Msg 'def:<&6><&o>%name%<&c><&o> members not updated!'
}
removemember:
# /drg reomvemember [ID] g:group player
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Parse specified members
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
- define members '<def[args].get[3].to[<def[args].size>].replace[:].with[;]||null>'
}
else {
- define members '<c.args.get[3].to[<c.args.size>].replace[:].with[;]||null>'
}
- if <def[members].is_empty||true> {
- run s@dRegions_Msg 'def:<&c>Must specify at least one member'
- queue clear
}
- foreach %members% {
- if <def[value].starts_with[g;]||false> {
- define group '<def[value].replace[g;]>'
- define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.members.groups]||li@>'
- if <def[groups].contains[%group%].not||true> {
- run s@dRegions_Msg 'def:<&c>Group %group% is not a member'
- foreach next
}
- define pass true
- yaml set 'regions.%name%.members.groups:<-:%group%' 'id:dRegions_%world%_regions'
}
else {
- if !<def[value].as_player.is[!=].to[null]||false> {
- foreach next
}
- define players '<yaml[dRegions_%world%_regions].read[regions.%name%.members.players]||li@>'
- if <def[players].contains[<def[value].as_player.uuid>].not||true> {
- run s@dRegions_Msg 'def:<&c>Player %value% is not a member'
- foreach next
}
- define pass true
- yaml set 'regions.%name%.members.players:<-:<def[value].as_player.uuid>' 'id:dRegions_%world%_regions'
}
}
- if <def[pass].exists||false> {
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> members updated'
}
else {
- run s@dRegions_Msg 'def:<&6><&o>%name%<&c><&o> members not updated!'
}
list:
# /drg list (page#) -r region -w world -p player
- define args '<c.args.remove[1]>'
# Check the specified player
- if <def[args].find[-p].is[OR_MORE].than[0]||false> {
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- run s@dRegions_Msg 'def:<&c>You may not list other players regions!'
- queue clear
}
- define player '<def[args].get[<def[args].find[-p].add[1].as_int>].escaped||null>'
- if !<def[player].as_player.is[!=].to[null]||false> {
- run s@dRegions_Msg 'def:<&c>Invalid player specfied!'
- queue clear
}
- define filterPlayer ''
- define args '<def[args].remove[<def[args].find[-p].add[1].as_int>].exclude[-p]||li@>'
}
else {
- if <context.server.not> {
- define player '<player.name>'
}
else {
- define player 'null'
}
}
# Check the specified world
- if <def[args].find[-w].is[OR_MORE].than[0]||false> {
- define world '<def[args].get[<def[args].find[-w].add[1].as_int>].as_world.name.to_lowercase.escaped||null>'
- if <def[world].is[==].to[null]||true> {
- run s@dRegions_Msg 'def:<&c>Invalid world specfied!'
- queue clear
}
- define filterWorld ''
- define args '<def[args].remove[<def[args].find[-w].add[1].as_int>].exclude[-w]||li@>'
}
else {
- if <context.server.not> {
- define world '<player.world.name.to_lowercase>'
}
else {
- define world 'null'
}
}
# Does the player want to list the regions where he stands?
- if <def[args].find[-h].is[OR_MORE].than[0]||false> {
- define filterHere ''
- define args '<def[args].remove[<def[args].find[-h]>]||li@>'
}
# Do we want to show results for ALL worlds?
- if <def[args].find[-a].is[OR_MORE].than[0]||false> {
- define worlds '<server.list_worlds.parse[name.to_lowercase]>'
- define getAll ''
- define args '<def[args].remove[<def[args].find[-a]>]||li@>'
}
# Check the specified region name
- if <def[args].find[-r].is[OR_MORE].than[0]||false> {
- define region '<def[args].get[<def[args].find[-r].add[1].as_int>].escaped||null>'
- if <def[region].is[!=].to[null]||true> {
- define exists '<proc[dRegions_RegionExists].context[<def[region]>|<def[world]>]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
}
else {
- run s@dRegions_Msg 'def:<&c>You must specify a valid region ID!'
- queue clear
}
- define filterRegion ''
- define args '<def[args].remove[<def[args].find[-r].add[1].as_int>].exclude[-r]||li@>'
}
# OK, we've validated all the user input, let's get the regions and apply filters
- define regions li@
- if <def[filterHere].exists> {
- define standingIn '<player.location.cuboids.parse[notable_name].filter[split[_].get[1].is[==].to[dRegions]].parse[after[dregions_%world%_]].replace[li@].replace[|].with[,]>'
- define worldRegions '<proc[dRegions_HighestPriority].context[%world%|%standingIn%]||li@>'
- if <def[worldRegions].is_empty||true> {
- define worldRegions 'li@__global__'
}
- inject locally filterRegionList
}
else if <def[getAll].exists> {
- foreach %worlds% {
- define world %value%
- define worldRegions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- inject locally filterRegionList
}
}
else {
- define worldRegions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
- inject locally filterRegionList
}
# Display the list
- define page '<def[args].get[1].replace[-].escaped||1>'
- if <def[page].is[MATCHES].to[number].not> {
- define page '1'
}
- define pages '<def[regions].size.div[14].round_up||1>'
- if <def[page].is[MORE].than[%pages%]> {
- define page '%pages%'
}
- define highNumber '<def[page].mul[14].as_int>'
- define lowNumber '<def[highNumber].sub[13].as_int>'
- define msgsHeaderTitle '<&e>Region List <el@val[<&7><&o>Page <&f><&o>%page% <&7><&o>of %pages%].pad_left[30]>'
- inject locally msgsHeader instantly
- foreach <def[regions].get[%lowNumber%].to[%highNumber%]||li@> {
- define color '<t[<def[value].split[/].get[3].is[==].to[owner]>]:&6||<t[<def[value].split[/].get[3].is[==].to[member]>]:&e||&f>>'
- narrate "<&5>|<&sp><&7><el@val[<el@val[<def[lowNumber].add[<def[loop_index].sub[1]>].as_int>.].pad_left[4].with[<&sp>]>].pad_right[5].with[<&sp>]> <%color%><def[value].split[/].get[2]>"
}
- narrate "<&5>|"
- inject locally msgsFooter instantly
flag:
# /drg flag [ID] [flag] [value] -g group -w world
- define args '<c.args.remove[1]>'
# Check the specified world
- if <def[args].find[-w].is[OR_MORE].than[0]||false> {
- define world '<def[args].get[<def[args].find[-w].add[1].as_int>].as_world.name.escaped.to_lowercase||null>'
- if <def[world].is[==].to[null]||true> {
- run s@dRegions_Msg 'def:<&c>Invalid world specfied!'
- queue clear
}
- define args '<def[args].remove[<def[args].find_all[-w].parse[add[1].as_int]>].exclude[-w]||li@>'
}
else {
- if <context.server.not> {
- define world '<player.world.name.to_lowercase>'
}
else {
- define world 'null'
}
}
# Check the specified group
- if <def[args].find[-g].is[OR_MORE].than[0]||false> {
- define group '<def[args].get[<def[args].find[-g].add[1].as_int>].escaped.to_lowercase||null>'
- if !<el@val[members|nonmembers|owners|nonowners|all].as_list.contains[%group%]||false> {
- run s@dRegions_Msg 'def:<&c><def[group].unescaped> is an invalid group!'
- queue clear
}
- define args '<def[args].remove[<def[args].find_all[-g].parse[add[1].as_int]>].exclude[-g]||li@>'
}
# Check the specified region name
- define region '<def[args].get[1].escaped.to_lowercase||null>'
- if <def[region].is[!=].to[null]||true> {
- define exists '<proc[dRegions_RegionExists].context[<def[region]>|<def[world]>]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
}
else {
- run s@dRegions_Msg 'def:<&c>You must specify a valid region ID!'
- queue clear
}
# Check the specified flag name
- define flag '<def[args].get[2].escaped.to_lowercase||null>'
- if <def[flag].is[!=].to[null]||true> {
- define flags '<server.list_scripts.filter[starts_with[s@dRegions_Flag_]].parse[name.split[_].get[3]]||li@>'
- if !<def[flags].contains[%flag%]||false> {
- run s@dRegions_Msg 'def:<&c>You must specify a valid region flag!'
- queue clear
}
}
else {
- run s@dRegions_Msg 'def:<&c>You must specify a valid region flag!'
- queue clear
}
# By this point, we know the flag is being set or cleared, so let's clear the flag
# cache for this region, any child regions, and any overlapping regions including __global__
- run s@dRegions p:clearCache delay:1t 'def:%region%|%world%|%flag%'
# Check the specified flag value and set or clear it.
- define flagValue '<def[args].get[3].to[<def[args].size>].space_separated.escaped||null>'
- if <def[flagValue].is[!=].to[null]||true> {
- define type '<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
- if <def[type].is[==].to[location]> {
- if <def[flagValue].is[==].to[here]||true> {
- define flagValue '<player.location.simple>'
}
}
- define typeMatch '<proc[dRegion_FlagTypeMatch].context[%flagValue%|%flag%]>'
- if !<def[TypeMatch]> {
- define lines '<proc[dRegions_LineWrap].context[<s@dRegions_Flag_%Flag%.yaml_key[flag_help]||<&c>%flag% flag requires a %type% value!>|45]>'
- foreach <def[lines]> {
- run s@dRegions_Msg 'def:<&c><def[value]>'
}
- queue clear
}
- if <def[type].starts_with[state]||false>
&& <def[flagValue].is[==].to[none]||false> {
- inject s@dRegions_Flag_%flag% p:command_handler
- yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/cache.yml' 'id:dRegions_%world%_cache'
- run s@dRegions_Msg 'def:<&c>Cleared %flag% flag for region %region%'
- queue clear
}
- inject s@dRegions_Flag_%flag% p:command_handler
- if <s@dRegions_Flag_%flag%.yaml_key[flag_takeGroup]||false> {
- if <def[group].exists> {
- yaml set 'regions.%region%.flags.%flag%:<def[flagValue].unescaped>/%group%' 'id:dRegions_%world%_regions'
}
else {
- yaml set 'regions.%region%.flags.%flag%:<def[flagValue].unescaped>' 'id:dRegions_%world%_regions'
}
}
else {
- yaml set 'regions.%region%.flags.%flag%:<def[flagValue].unescaped>' 'id:dRegions_%world%_regions'
}
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/cache.yml' 'id:dRegions_%world%_cache'
- define string "<&f><&o>%region%<&7><&o> set %flag% flag to <&f><&o>%flagValue%"
- define lines '<proc[dRegions_LineWrap].context[<def[string]>|45]>'
- foreach <def[lines]> {
- run s@dRegions_Msg 'def:<&f><&o><def[value].unescaped>'
}
}
else {
- inject s@dRegions_Flag_%flag% p:command_handler
- yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&c>Cleared %flag% flag for region %region%'
- queue clear
}
setpriority:
# /drg setpriority [ID] [#]
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Verify specified priority
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
- define priority '<def[args].get[3].escaped||null>'
}
else {
- define priority '<c.args.get[3].escaped||null>'
}
- if <def[priority].is[matches].to[number].not||true> {
- run s@dRegions_Msg 'def:<&c>Must specify a numeric value for priority'
- queue clear
}
# Update region
- yaml set 'regions.%name%.priority:%priority%' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> set priority to <&f><&o>%priority%'
setparent:
# /drg setparent [ID] [parent]
- inject locally prerun instantly
# Check if child region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Check if parent region exists
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
- define parent '<def[args].get[3].escaped||null>'
}
else {
- define parent '<c.args.get[3].escaped||null>'
}
- if %parent% == null {
- define parent <yaml[dRegions_%world%_regions].read[regions.%name%.parent]||null>
- if %parent% != null {
- yaml set 'regions.%parent%.children:<-:%name%' 'id:dRegions_%world%_regions'
}
- yaml set 'regions.%name%.parent:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&7><&o>Unset parent for <&f><&o>%name%'
- queue clear
}
# Check if parent region exists
- define exists '<proc[dRegions_RegionExists].context[%parent%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Check if player owns parent
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%parent%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Update the region
- yaml set 'regions.%name%.parent:%parent%' 'id:dRegions_%world%_regions'
- if <yaml[dRegions_%world%_regions].read[regions.%parent%.children]||li@> contains %name% {
- yaml set 'regions.%parent%.children:<-:%name%' 'id:dRegions_%world%_regions'
}
else {
- yaml set 'regions.%parent%.children:->:%name%' 'id:dRegions_%world%_regions'
}
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> set parent to <&f><&o>%parent%'
teleport:
- narrate "Stub"
remove:
# /drg remove [ID] -w world
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists].is[==].to[orphan]> {
- run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
- run s@dRegions_Msg 'def:<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@dRegions_Msg 'def:<&c>There is no region by this name!'
- queue clear
}
# Don't remove the __global__ region
- if <def[name].is[==].to[__global__]> {
- run s@dRegions_Msg 'def:<&c>You can not remove the __global__ region!'
- queue clear
}
# Check if is owner
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
- queue clear
}
}
# Remove region from ancestry
# This should be done smarterer now since regions know both children and parents.
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__]||li@>'
- foreach %regions% {
- if <yaml[dRegions_%world%_regions].read[regions.%value%.parent]||null> == %name% {
- yaml set 'regions.%value%.parent:<-:%name%' 'id:dRegions_%world%_regions'
}
- if <yaml[dRegions_%world%_regions].read[regions.%value%.children]||li@> contains %name% {
- yaml set 'regions.%value%.children:<-:%name%' 'id:dRegions_%world%_regions'
}
}
# Remove the region
- yaml set 'regions.%name%:!' 'id:dRegions_%world%_regions'
- note remove 'as:dregions_%world%_%name%'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> has been removed from <&f><&o>%world%'
#
# END dRegions Command Arguments
#--------------------------------------
#
# dRegions Command Utilities
#
# Just some commonly used code blocks
#
prerun:
# Block of checks run before /most/ commands
- if !<player.has_permission[dRegions.%command%]||<player.is_op||false>> {
- inject locally help
- queue clear
}
- if <c.args.find[-w].is[OR_MORE].than[0]||false> {
- define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||null>'
- if <def[world].is[==].to[null]||true> {
- run s@dRegions_Msg 'def:<&c>Invalid world specfied!'
- run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
- queue clear
}
- define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
- define name '<def[args].get[2].escaped.to_lowercase||null>'
}
else {
- define world '<player.world.name.to_lowercase>'
}
- if <li@define|redefine|claim.contains[%command%]> {
- define wandType '<player.flag[dWEWand_Type]||cuboid>'
- if <li@cuboid|extender.contains[%wandType%].not||true> {
- run s@dRegions_Msg 'def:<&c>You must select a cuboid type region!'
- run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
- queue clear
}
- define pos1 '<player.flag[dWEWand].get[1].as_location||null>'
- define pos2 '<player.flag[dWEWand].get[2].as_location||null>'
- if <def[pos1].is[==].to[null]>
|| <def[pos2].is[==].to[null]> {
- run s@dRegions_Msg 'def:<&c>No region selected!'
- run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
- queue clear
}
- if <def[pos1].world.name.is[!=].to[%world%]>
|| <def[pos2].world.name.is[!=].to[%world%]> {
- run s@dRegions_Msg 'def:<&c>Selected region not within specified world!'
- run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
- queue clear
}
- define selectedCuboid '<cu@%pos1%|%pos2%>'
}
- define name '<def[name]||<c.args.get[2].escaped.to_lowercase||null>>'
- if '<def[name].is[==].to[null]||true>' {
- if <li@info|select.contains[%command%]> {
- define dRegions '<player.location.cuboids.parse[notable_name].filter[split[_].get[1].is[==].to[dRegions]].parse[after[dregions_%world%_]].replace[li@].replace[|].with[,]>'
- define orderedRegions '<proc[dRegions_HighestPriority].context[%world%|%dRegions%]>'
- if <def[orderedRegions].is_empty||true> {
- define name '__global__'
}
else {
- define name '<def[orderedRegions].get[1]>'
- if <def[orderedRegions].size.is[MORE].than[1]> {
- run s@dRegions_Msg 'def:<&c><&o>There are multiple regions at this location!'
- run s@dRegions_Msg 'def:<&7><&o>Getting highest priority region info.'
}
}
}
else {
- run s@dRegions_Msg 'def:<&c>You must specify a region ID!'
- run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
- queue stop
}
}
- if '<def[name].matches[^[a-z0-9-_]+$].not>' {
- run s@dRegions_Msg 'def:<&c>Region ID may only contain letters, numbers,'
- run s@dRegions_Msg 'def:<&c>hyphen, and underscore!'
- run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
- queue stop
}
# - inject s@dRegions_Commands p:selection_Size instantly
# - define oldSize '%size%'
filterRegionList:
# Used in /drg list to apply various filters
- if <def[filterRegion].exists||false> {
- define filteredRegions 'li@'
- foreach %worldRegions% {
- define worldRegion '%value%'
- if <yaml[dRegions_%world%_regions].read[regions.%worldRegion%.parent].is[==].to[<def[region]>]||false> {
- define filteredRegions '<def[filteredRegions].include[%worldRegion%]||<def[filteredRegions]>>'
}
}
}
- if <def[filteredRegions].exists> {
- define worldRegions '<def[filteredRegions]>'
}
- foreach %worldRegions% {
- define worldRegion '%value%'
- if <proc[dRegions_IsOwner].context[<def[worldRegion]>|<def[world]>|<def[player].as_player>]||false> {
- define regions '<def[regions].include[<def[world]>/<def[worldRegion]>/owner]||<def[regions]>>'
}
else if <proc[dRegions_IsMember].context[<def[worldRegion]>|<def[world]>|<def[player].as_player>]||false> {
- define regions '<def[regions].include[<def[world]>/<def[worldRegion]>/member]||<def[regions]>>'
}
else if <def[filterPlayer].exists.not||true> {
- define regions '<def[regions].include[<def[world]>/<def[worldRegion]>/nonmember]||<def[regions]>>'
}
}
regionInfo:
# Build the data set for region info
- define type '<yaml[dRegions_%world%_regions].read[regions.%name%.type]||null>'
- if <def[type].is[==].to[cuboid]||false> {
- define POS1 '<yaml[dRegions_%world%_regions].read[regions.%name%.min]||null>'
- define POS2 '<yaml[dRegions_%world%_regions].read[regions.%name%.max]||null>'
- inject s@dWE_Commands p:selection_Size instantly
}
else if <def[type].is[==].to[global]||false> {
- define POS1 '0,0,0,%world%'
- define POS2 '0,0,0,%world%'
- define size 'infinite'
}
else {
- run s@dRegions_Msg 'def:<&c>This region is misconfigured!'
- run s@dRegions_Msg 'def:<&c>Notify an Admin!'
- queue clear
}
- define priority '<yaml[dRegions_%world%_regions].read[regions.%name%.priority]||0>'
- define parent '<yaml[dRegions_%world%_regions].read[regions.%name%.parent]||<&c>none>'
- define ownerGroups '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.groups]||li@>'
- define ownerPlayers '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.players]||li@>'
- define memberGroups '<yaml[dRegions_%world%_regions].read[regions.%name%.members.groups]||li@>'
- define memberPlayers '<yaml[dRegions_%world%_regions].read[regions.%name%.members.players]||li@>'
- define flagList '<yaml[dRegions_%world%_regions].list_keys[regions.%name%.flags]||li@>'
- define flags 'li@'
- foreach %flagList% {
- define flags '<def[flags].include[%value%/<yaml[dRegions_%world%_regions].read[regions.%name%.flags.%value%].as_list.comma_separated||null>]||%flags%>'
}
#
# END dRegions dRegions Command Utilities
#--------------------------------------
#
# dRegions Command Messages
#
# Some messages used by commands. Should probably move to s@dRegions_Msg
#
msgsHeader:
- narrate "<&5>|----------------------------------------|"
- narrate "<&5>|<&sp><&sp><&sp><&6>dRegions <&7><def[msgsHeaderTitle]||>"
- narrate "<&5>|<&f>"
msgsFooter:
- define anthony "text<&co>'<&7>|Anthony|',clickEvent<&co><&chr[007B]>action<&co>open_url,value<&co>'http<&co>//mineconomy.org'<&chr[007D]>,hoverEvent<&co><&chr[007B]>action<&co>show_item,value<&co>'<&chr[007B]><i@AnthonyBanner.json><&chr[007D]>'<&chr[007D]>"
- define spacer "text<&co>' '"
- define prefix "text<&co>'<&5>| <&f>Authors<&co> '"
- if <player.is_player||false> {
- execute as_server "tellraw <player.name> <&chr[007B]>text<&co>'',extra<&co>[<&chr[007B]>%prefix%<&chr[007D]>,<&chr[007B]>%anthony%<&chr[007D]>]<&chr[007D]>"
}
else {
- announce to_console "<&5>| <&f>Authors<&co> <&7>|Anthony|"
}
- narrate "<&5>|-----------<&d>S<&5>-<&d>c<&5>-<&d>r<&5>-<&d>o<&5>-<&d>l<&5>-<&d>l<&5>---<&d>U<&5>-<&d>p<&5>-------------|"
msgsHelpAdmin:
# Filter the list of commands this player can use
- define commands '<script.list_keys[commandArgs].alphanumeric.to_lowercase||li@>'
- foreach %commands% {
- if !<player.has_permission[dregions.%value%]||<player.is_op||<c.server||false>>> {
- define commands '<def[commands].exclude[%value%]>'
}
else {
- foreach next
}
}
# Display the list
- define page '<def[arg].replace[-].escaped||1>'
- if <def[page].is[MATCHES].to[number].not> {
- define page '1'
}
- define pages '<def[commands].size.div[5].round_up||1>'
- if <def[page].is[MORE].than[%pages%]> {
- define page '%pages%'
}
- define highNumber '<def[page].mul[5].as_int>'
- define lowNumber '<def[highNumber].sub[4].as_int>'
- define msgsHeaderTitle '<&e>Admin Help <el@val[<&7><&o>Page <&f><&o>%page% <&7><&o>of %pages%].pad_left[30]>'
- inject locally msgsHeader instantly
- foreach <def[commands].get[%lowNumber%].to[%highNumber%]||li@> {
- narrate "<&5>|<&sp><&sp><&f><def[value].to_titlecase><&co>"
- narrate "<&5>|<&sp><&sp><&sp><&sp><&7><script.yaml_key[commandArgs.%value%.usage]||No usage info available!>"
}
- narrate "<&5>|"
msgsHelpUser:
- define msgsHeaderTitle 'User Help'
- inject locally msgsHeader instantly
- define par1 "dRegions is an advanced region management and world protection system written with the Denizen Scripting Engine."
- define par2 "Heavily inspired by WorldGuard, the goal is to have an extremely efficient events system supporting an exhaustive set of region flags and configuration options."
- define par3 "dRegions offers an intuitive command interface and provides thorough TAB completion."
- define strings "<el@val[%par1%|%par2%|%par3%].as_list>"
- foreach <def[strings]> {
- define string "<&f><&sp><def[value]>"
- define lines '<proc[dRegions_LineWrap].context[<def[string]>|44]>'
- foreach <def[lines]> {
- narrate "<&5>|<&f><&sp><&sp><def[value].unescaped>"
}
- narrate "<&5>|"
}
#
# END dRegions Command Messages
#--------------------------------------
#
# I want to test moving all command arguments to their own command script so I
# can have the dregions command and the alias of these scripts run the same
# code. I'd like to add the flexibility for folks to type the full command
# /dregions select
# or the shorter alias
# /.sel
# and use the same code base, tab completion and all
#
# -----
# dRegions Select Command
#
# Select a region by ID and optionally world
#
#dRegions_Command_Sel:
# type: command
# debug: false
# name: select
# description: Select a region by ID and optionally world
# usage: /.sel
# aliases:
# - .sel
# allowed help:
# - determine true
# tab complete:
# - define args 'li@help|reload|define|redefine|claim|select|info|addowner|removeowner|addmember|removemember|list|flag|setpriority|setparent|teleport|remove'
# - define arg '<c.args.get[1]||null>'
# - if <def[arg].is[==].to[null]>
# || !<def[args].contains[%arg%]> {
# - inject locally tab_arg_1
# }
# else inject locally tab_%arg%
# - determine '<def[result]||li@>'
# script:
# # We only want to run it if the user issues the alias /.sel command
# - if <c.alias.is[!=].to[.sel]||true> queue clear
# - define command 'select'
# - define args 'li@help|reload|select|define|redefine|remove|addowner|addmember|setparent|setpriority'
# - if !<def[args].contains[%command%]> inject locally help instantly
# else inject locally %command% instantly
# sel:
# # /drg select [ID]
# - inject locally prerun instantly
# # Check if region exists
# - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
# - if <def[exists].is[==].to[orphan]> {
# - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
# - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
# - queue clear
# }
# else if <def[exists].not> {
# - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
# - queue clear
# }
# # Check if is owner
# - if !<player.has_permission[dregions.admin]||false> {
# - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
# - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
# - queue clear
# }
# }
# - define min '<yaml[dRegions_%world%_regions].read[regions.%name%.min].as_location.simple||null>'
# - define max '<yaml[dRegions_%world%_regions].read[regions.%name%.max].as_location.simple||null>'
# - flag <player> 'dWEWand_Type:cuboid'
# - flag <player> dWEWand:!
# - flag <player> dWEWand:|:%min%|%max%
# - run s@dRegions_Msg 'def:<&7><&o>Selected <&f><&o>%name%'
# prerun:
# # Block of checks run before /most/ commands
# - if !<player.has_permission[dRegions.%command%]||<player.is_op||false>> {
# - inject locally help
# - queue clear
# }
# - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
# - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name||null>'
# - if <def[world].is[==].to[null]||true> {
# - run s@dRegions_Msg 'def:<&c>Invalid world specfied!'
# - queue clear
# }
# - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
# - define name '<def[args].get[2].escaped||null>'
# }
# else define world '<player.world.name>'
# - if <li@define|redefine|claim.contains[%command%]> {
# - define wandType '<player.flag[dWEWand_Type]||cuboid>'
# - if <li@cuboid|extender.contains[%wandType%].not||true> {
# - run s@dRegions_Msg 'def:<&c>You must select a cuboid type region!'
# - queue clear
# }
# - define pos1 '<player.flag[dWEWand].get[1].as_location||null>'
# - define pos2 '<player.flag[dWEWand].get[2].as_location||null>'
# - if <def[pos1].is[==].to[null]>
# || <def[pos2].is[==].to[null]> {
# - run s@dRegions_Msg 'def:<&c>No region selected!'
# - queue clear
# }
# - if <def[pos1].world.name.is[!=].to[%world%]>
# || <def[pos2].world.name.is[!=].to[%world%]> {
# - run s@dRegions_Msg 'def:<&c>Selected region not within specified world!'
# - queue clear
# }
# - define selectedCuboid '<cu@%pos1%|%pos2%>'
# }
# - define name '<def[name]||<c.args.get[2].escaped||null>>'
# - if <def[name].is[==].to[null]||true> {
# - run s@dRegions_Msg 'def:<&c>You must specify a name!'
# - queue stop
# }
#
# END dRegions Command Script Basics
#--------------------------------------
#
# dRegions Command TAB Completion
#
# Each of these subscripts handles TAB completion for the positional argument.
#
#
#--------------------------------------
#
# dRegions Other Utilities
#
# Other Utility functions used throughout dRegions
#
##dRegions_HasPerm:
## I have to think about this more...
## # A procedure script to check if a player has any of the required permissions for a command
## # <proc[dRegions_HasPerm].context[command|player|region]>
## type: procedure
## definition: command|player|region
## constants:
## define:
## - admin
## - define
## redefine:
## - admin
## - redefine
## - redefine.own.*
## - redefine.own.%region%
## - redefine.member.*
## - redefine.member.%region%
##
## script:
## - if '<def[region].exsits.not||true>' determine false
## - define perms <script.constant[%command%]>
dRegions_RegionSort:
type: procedure
definitions: region1|region2
speed: 0
debug: false
script:
- define region1pri '<def[region1].split[/].get[1]>'
- define region2pri '<def[region2].split[/].get[1]>'
- if %region1pri% > %region2pri% {
- determine -1
}
- if %region1pri% < %region2pri% {
- determine 1
}
- if %region1pri% == %region2pri% {
- determine 0
}
dRegions_IsOwner:
# A procedure script to check if a player is a region owner
# <proc[dRegions_IsOwner].context[region|world|player]>
type: procedure
definitions: region|world|player
speed: 0
debug: false
script:
- define playerUUID '<def[player].uuid>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> {
- determine 'true'
}
- define playerGroups '<def[player].groups||li@>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
# Regions inherit members and owners.
- while <el@a.is[==].to[a]> {
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]||null>'
- if %region% == null {
- while stop
}
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> {
- determine 'true'
}
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
}
- determine 'false'
dRegions_IsMember:
# A procedure script to check if a player is a region member
# <proc[dRegions_IsMember].context[region|world|player]>
type: procedure
definitions: region|world|player
speed: 0
debug: false
script:
- define playerUUID '<def[player].uuid>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> {
- determine 'true'
}
- define playerGroups '<def[player].groups||li@>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
# Regions inherit members and owners.
- while <el@a.is[==].to[a]> {
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]||null>'
- if %region% == null {
- while stop
}
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> {
- determine 'true'
}
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
}
- determine 'false'
dRegions_RegionExists:
# A procedure script to check if a region exists
# <proc[dRegions_RegionExists].context[region|world]>
type: procedure
definitions: region|world
speed: 0
debug: false
script:
- if %region% == '__global__' {
- determine true
}
# - define notables '<cu@dregions_%world%_%region%.is[!=].to[null].not||true>'
- define notables '<server.list_notables[cuboids].contains[cu@dregions_%world%_%region%].not||true>'
- define regions '<yaml[dRegions_%world%_regions].contains[regions.%region%].not||true>'
- if %notables% && %regions% {
- determine false
}
else if %notables% || %regions% {
- determine orphan
}
else {
- determine true
}
dRegions_HighestPriority:
# Filter a list of regions by priority in descending order
# <proc[dRegions_HighestPriority].context[world|region1,...]>
type: procedure
definitions: world|regions
speed: 0
debug: false
script:
- define regions '<def[regions].split[,]||li@>'
- define regionPri 'li@'
- foreach %regions% {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- determine '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
dRegions_RegionOverlaps:
# A procedure script to check if a region overlaps other (un)owned regions
# <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|%name%|%world%|<player>]>
# NOTE: If for some reason the selected cuboid overlaps an unowned region that is a lower priority than
# a region that the player does own and is completely within, it will not be considered as an overlap!
# - But why would there be a lower priority region inside a higher priority region... that's not
# how priorities should be used!
type: procedure
definitions: selectedCuboid|world|player
speed: 0
debug: false
script:
- define selectedCuboid '<def[selectedCuboid].split[/].as_cuboid>'
- define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__]||li@>'
- define notables '<def[regions].parse[replace[regex:^].with[cu@dregions_%world%_]].filter[as_cuboid.is[!=].to[null]]||li@>'
- define overlaps '<def[notables].filter[intersects[<def[selectedCuboid]>]].parse[replace[cu@dregions_%world%_]]||li@>'
- define orderedRegions '<proc[dRegions_HighestPriority].context[%world%|<def[overlaps].replace[li@].replace[|].with[,]>]||li@>'
- foreach <def[orderedRegions]> {
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- determine true
}
# - if <proc[dRegions_CuboidIsWithinCuboid].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|<def[value].replace[regex:^].with[cu@dregions_%world%_].as_cuboid.full.replace[cu@].replace[|].with[/]>]> {
- if <def[selectedCuboid].is_within[<def[value].replace[regex:^].with[cu@dregions_%world%_].as_cuboid>]> {
- determine false
}
}
# By this point, we've determined that the player either owns all the regions at this cuboid location
# or that the new cuboid is completely within a region that he does own.
- determine false
dRegions_PlayerMatchRegionGroup:
# Check if a player matches a region flag group setting.
# <proc[dRegions_PlayerMatchRegionGroup].context[group|region|world|player]>
type: procedure
definitions: group|region|world|player
speed: 0
debug: false
script:
- inject locally %group%
all:
- determine 'true'
members:
- determine '<proc[dRegions_isMember].context[%region%|%world%|%player%]>'
nonmembers:
- if <proc[dRegions_isOwner].context[%region%|%world%|%player%]> {
- determine 'false'
}
- if <proc[dRegions_isMember].context[%region%|%world%|%player%]> {
- determine 'false'
}
- determine 'true'
owners:
- determine '<proc[dRegions_isOwner].context[%region%|%world%|%player%]>'
nonowners:
- determine '<proc[dRegions_isOwner].context[%region%|%world%|%player%].not>'
dRegions_CuboidIsWithinCuboid:
# Checks if one cuboid is completely within another cuboid
# <proc[dRegions_CuboidIsWithinCuboid].context[inner|outer]>
type: procedure
definitions: inner|outer
speed: 0
debug: false
script:
- define innerCuboid '<def[inner].split[/].as_cuboid>'
- define outerCuboid '<def[outer].split[/].as_cuboid>'
- if <def[innerCuboid].min.x.is[OR_MORE].than[<def[outerCuboid].min.x>]>
&& <def[innerCuboid].min.y.is[OR_MORE].than[<def[outerCuboid].min.y>]>
&& <def[innerCuboid].min.z.is[OR_MORE].than[<def[outerCuboid].min.z>]>
&& <def[innerCuboid].max.x.is[OR_LESS].than[<def[outerCuboid].max.x>]>
&& <def[innerCuboid].max.y.is[OR_LESS].than[<def[outerCuboid].max.y>]>
&& <def[innerCuboid].max.z.is[OR_LESS].than[<def[outerCuboid].max.z>]> {
- determine true
}
else {
- determine false
}
dRegions_GetInheritedFlag:
# Get a region flag value. Start at current child and ascend through parents
# until a value is set or you reach the origin ancestor
# <proc[dRegions_GetInheritedFlag].context[world|region|flag]>
type: procedure
definitions: world|region|flag
speed: 0
debug: false
script:
- define return '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%]||null>'
- while <def[return].is[==].to[null]> {
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]||null>'
- if %region% == null {
- while stop
}
- define return '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%]||null>'
}
- determine '%return%'
dRegions_CanUse_Block:
# Procedure script to determine if a player can use a block at a location.
# Will work for any block that can be interacted with (chests, doors, levers, etc.)
# <proc[dRegions_CanUse_Block].context[player|location]>
type: procedure
speed: 0
debug: false
definitions: player|location
script:
- define world '<def[location].world.name>'
- define target '<def[location].material.bukkit_enum>'
- define FlagScript '<s@dRegions_Map_Interactions.yaml_key[block.%target%]||s@dRegions_Map_Interactions>'
- define flag '<def[FlagScript].yaml_key[flag_name]||null>'
- if %flag% == null determine false
- if <def[player].has_permission[dregions.admin]||<def[player].is_op>> determine true
- define flag-targetList '<def[FlagScript].yaml_key[flag_targetList]||null>'
- if <def[location].cuboids.is_empty||true> {
- inject locally check-global
- determine 'true'
- queue clear
}
- define regionPri 'li@'
- foreach <def[location].cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
- inject locally check-region
- determine 'true'
check-global:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>'
- if %flagObj% == null {
- define flagObj '<def[FlagScript].yaml_key[flag_globalDefault]||none>'
}
- if %flagObj% != none {
- if <def[flagObj].split[/].get[1]> == allow {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
# - inject %FlagScript% p:event-cleanup
- determine false
}
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
- if ( %targetList% != li@null ) && ( %targetList% != li@all ) && ( %targetList% !contains %target% ) {
# - inject %FlagScript% p:event-cleanup
- determine false
}
}
else {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
- if ( %targetList% == li@null ) || ( %targetList% == li@all ) || ( %targetList% contains %target% ) {
# - inject %FlagScript% p:event-cleanup
- determine false
}
}
}
}
check-region:
- if <def[FlagScript].yaml_key[region_highestOnly]||false> {
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag%]>'
}
else {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
}
- if %flagObj% == null {
- define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
}
- if %flagObj% != none {
- if <def[flagObj].split[/].get[1]> == allow {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
# - inject %FlagScript% p:event-cleanup
- determine false
}
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
- if ( %targetList% != li@null ) && ( %targetList% != li@all ) && ( %targetList% !contains %target% ) {
# - inject %FlagScript% p:event-cleanup
- determine false
}
}
else {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
- if ( %targetList% == li@null ) || ( %targetList% == li@all ) || ( %targetList% contains %target% ) {
# - inject %FlagScript% p:event-cleanup
- determine false
}
}
}
}
dRegions_getRelativeLocation:
# A procedure script to get a location relative to another location.
# Specify the direction as n s e w u d
# <proc[dRegions_getRelativeLocation].context[location|direction|distance]>
type: procedure
definitions: l|d|n
speed: 0
debug: false
n_math: sub
n_coord: '0,0,<def[n]>'
s_math: add
s_coord: '0,0,<def[n]>'
w_math: sub
w_coord: '<def[n]>,0,0'
e_math: add
e_coord: '<def[n]>,0,0'
d_math: sub
d_coord: '0,<def[n]>,0'
u_math: add
u_coord: '0,<def[n]>,0'
script:
- define math '<script.yaml_key[%d%_math]>'
- define coord '<script.yaml_key[%d%_coord]>'
- determine "<def[l].as_location.%math%[%coord%]>"
dRegions_LineWrap:
# Turn a long string into a list of smaller strings
type: procedure
definitions: string|targetLen
speed: 0
debug: false
script:
- define stringLen '<def[string].length>'
- if <def[stringLen].is[MORE].than[%targetLen%]> {
- define lines 'li@'
- while <def[stringLen].is[MORE].than[0]> {
- define low '<def[increment].add[1].as_int||1>'
- define hi '<def[increment].add[<def[targetLen].add[1]>].as_int||%targetLen%>'
- define pass '<def[string].substring[%low%,%hi%]>'
- if <def[pass].length.is[==].to[%stringLen%]> {
- define lines '<def[lines].include[%pass%]||<def[lines]>>'
- while stop
}
else {
- define brake '<def[pass].last_index_of[ ]>'
- define increment '<def[increment].add[%brake%]||%brake%>'
- define passtrim '<def[pass].substring[1,<t[<def[brake].is[MORE].than[0]>]:%brake%||<def[pass].length>>]>'
- define lines '<def[lines].include[%passtrim%]||<def[lines]>>'
- define stringLen '<def[stringLen].sub[%brake%]>'
}
- if <def[loop_index].is[MORE].than[10]> {
- while stop
}
}
- determine '<def[lines].as_list>'
}
else {
- determine '<def[string].as_list>'
}
################################################################################
#
# FlagTypeMatch Procedure script
#
# Used to check that the player specified value matches the type required
# by the flag.
#
# Use this to compare 2 values. Check if they are one of NUMBER, DECIMAL,
# LOCATION, BOOLEAN, STATE, GROUP, LIST or any other STRING.
#
# usage:
# - define YourValue "Some string"
# - define Type "<s@dRegions_Flag_%flag%.yaml_key[flag_type]||null>"
# - define TypeMatch '<proc[dRegion_FlagTypeMatch].context[%YourValue%|%flag%]>'
# - if <def[TypeMatch]> {
# - narrate "%YourValue% matches %type%."
# }
# else {
# - narrate "%YourValue% is a %YourValueType% not a %type%"
# }
#
dRegion_FlagTypeMatch:
type: procedure
speed: 0
debug: false
definitions: YourValue|Flag
script:
- define Type "<s@dRegions_Flag_%Flag%.yaml_key[flag_type]||null>"
- if <def[Type].is[==].to[number]> {
- if <def[YourValue].is[MATCHES].to[number]> {
- determine 'true'
}
else {
- determine 'false'
}
}
- if <def[Type].is[==].to[decimal]> {
- if <def[YourValue].is[MATCHES].to[decimal]> {
- determine 'true'
}
else {
- determine 'false'
}
}
- if <def[Type].is[==].to[boolean]> {
- if <def[YourValue].is[MATCHES].to[boolean]> {
- determine 'true'
}
else {
- determine 'false'
}
}
- if <def[Type].is[==].to[location]> {
- if <def[YourValue].as_location.world.is[!=].to[null]||false> {
- determine 'true'
}
else {
- determine 'false'
}
}
- if <def[Type].starts_with[state]> {
- if <el@val[allow|deny|none].as_list.contains[%YourValue%]||false> {
- determine 'true'
}
else {
- determine 'false'
}
}
- if <def[Type].is[==].to[group]> {
- if <el@val[members|nonmembers|owners|nonowners|all].as_list.contains[%YourValue%]||false> {
- determine 'true'
}
else {
- determine 'false'
}
}
- if <def[Type].is[==].to[list]> {
- if '<def[YourValue].split[ ].get[1].contains_any_text[-a|-r]||false>' {
- determine 'true'
}
else {
- determine 'false'
}
}
- if <def[Type].is[==].to[custom]> {
- if <s@dRegions_Flag_%flag%.yaml_key[flag_type_customVal].as_list.contains[%YourValue%]||false> {
- determine 'true'
}
else {
- determine 'false'
}
}
- if <def[Type].is[==].to[string]> {
- if <def[YourValue].is[!=].to[null]||false> {
- determine 'true'
}
else {
- determine 'false'
}
}
- determine 'false'
#
# END other utilities
#--------------------------------------
#
# dRegions author banner items
#
# Banner items representing the authors
#
dRegions_Author_Anthony:
type: item
speed: 0
debug: false
material: i@human_skull
display name: "<&f> |Anthony|"
lore:
- <&7> Owner<&co> <&e>M<&6>ine<&e>C<&6>onomy <&e>N<&6>etwork
- <&5>-------------------------
- <&7>
- <&7> I`ve been playing minecraft
- <&7> and running a server since
- <&7> 2010. I have fun and share
- <&7> what I do.
- <&7>
- <&9> Click To Visit
#
# END dRegions author banner items
#--------------------------------------
#
# dRegions Interaction Mapping
#
# Mapping what to do when interacting with blocks and items
#
dRegions_Map_Interactions:
type: yaml data
debug: false
# Used as a fallback for non-existent interaction mappings
event:
- queue clear
event-global:
- queue clear
block:
# Containers
chest: s@dRegions_Flag_Chest-Access
ender_chest: s@dRegions_Flag_Chest-Access
locked_chest: s@dRegions_Flag_Chest-Access
trapped_chest: s@dRegions_Flag_Chest-Access
dispenser: s@dRegions_Flag_Chest-Access
hopper: s@dRegions_Flag_Chest-Access
dropper: s@dRegions_Flag_Chest-Access
# Doors
trap_door: s@dRegions_Flag_Door-Access
iron_trapdoor: s@dRegions_Flag_Door-Access
wooden_door: s@dRegions_Flag_Door-Access
iron_door_block: s@dRegions_Flag_Door-Access
spruce_door: s@dRegions_Flag_Door-Access
birch_door: s@dRegions_Flag_Door-Access
jungle_door: s@dRegions_Flag_Door-Access
dark_oak_door: s@dRegions_Flag_Door-Access
acacia_door: s@dRegions_Flag_Door-Access
fence_gate: s@dRegions_Flag_Door-Access
spruce_fence_gate: s@dRegions_Flag_Door-Access
birch_fence_gate: s@dRegions_Flag_Door-Access
jungle_fence_gate: s@dRegions_Flag_Door-Access
dark_oak_fence_gate: s@dRegions_Flag_Door-Access
acacia_fence_gate: s@dRegions_Flag_Door-Access
# Switches
lever: s@dRegions_Flag_Use-Switches
wood_button: s@dRegions_Flag_Use-Switches
stone_button: s@dRegions_Flag_Use-Switches
wood_plate: s@dRegions_Flag_Use-Switches
stone_plate: s@dRegions_Flag_Use-Switches
iron_plate: s@dRegions_Flag_Use-Switches
gold_plate: s@dRegions_Flag_Use-Switches
# Utility Blocks
workbench: s@dRegions_Flag_Use-Utilities
furnace: s@dRegions_Flag_Use-Utilities
burning_furnace: s@dRegions_Flag_Use-Utilities
brewing_stand: s@dRegions_Flag_Use-Utilities
enchantment_table: s@dRegions_Flag_Use-Utilities
anvil: s@dRegions_Flag_Use-Utilities
beacon: s@dRegions_Flag_Use-Utilities
jukebox: s@dRegions_Flag_Use-Utilities
note_block: s@dRegions_Flag_Use-Utilities
# cauldron: useUtility
# tnt: useUtility
# Other blocks that change when clicked regardless of item in hand
flower_pot: s@dRegions_Flag_Build
cake_block: s@dRegions_Flag_Build
diode_block_on: s@dRegions_Flag_Build
diode_block_off: s@dRegions_Flag_Build
redstone_comparator_off: s@dRegions_Flag_Build
redstone_comparator_on: s@dRegions_Flag_Build
block_withItem:
# jukebox: s@dRegions_Flag_Use-Utilities/air/gold_record|green_record|record_3|record_4|record_5|record_6|record_7|record_8|record_9|record_10|record_11|record_12
cauldron: s@dRegions_Flag_Use-Utilities/bucket|water_bucket|glass_bottle
tnt: s@dRegions_Flag_Use-Utilities/flint_and_steel
activator_rail: s@dRegions_Flag_Vehicle-Place/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
detector_rail: s@dRegions_Flag_Vehicle-Place/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
powered_rail: s@dRegions_Flag_Vehicle-Place/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
rails: s@dRegions_Flag_Vehicle-Place/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
stationary_water: s@dRegions_Flag_Vehicle-Place/boat
water: s@dRegions_Flag_Vehicle-Place/boat
mob_spawner: s@dRegions_Flag_Build/monster_egg
item:
ink_sac:
gold_record: jukebox
glass_bottle: cauldron
flint_and_steel: tnt
#
# END dRegions Interaction Mapping
#--------------------------------------
################################################################################
# #
# Configuration Files #
# #
# These are the default config files. They will be used to build the default #
# configuration and data storage files. #
# #
#______________________________________________________________________________#
# #
#______________________________DO_NOT_EDIT_THIS_DATA___________________________#
#______________________________________________________________________________#
dRegions_Configurations:
type: yaml data
config:
version: 0.27
regions:
enable: true
invincibility-removes-mobs: false
wand: dWE_Wand
ownerOnDefine: false
claim:
max-volume: 0
only-inside-existing-regions: true
max-region-count-per-player:
default: 7
spread:
water: true
water-list: []
lava: true
lava-list: []
mycel: true
grass: true
mushroom: true
vines: true
physics:
gravel: true
sand: true
portal:
create: true
entity-enter: true
player-enter: true
fire:
ender_crystal: true
explosion: true
fireball: true
flint_and_steel: true
lava: true
spread: true
spread-list: []
destroyBlocks: true
destroyBlocks-list: []
entity:
changeBlocks: true
changeBlocks-list: []
explode: true
explode-list: []
entity-break-item_frame: true
entity-break-painting: true
blockform:
ice: true
snow: true
snow-list: []
blockfade:
ice: true
snow: true
lightning-strike: true
lightning-strike-list: []
trample-crops:
player: true
entity: true
leaf-decay: true
player-damage: true
player-damage-list: []
# auto-invincible: false
# protection:
# item-durability: true
# remove-infinite-stacks: false
# disable-xp-orb-drops: false
# disable-obsidian-generators: true
# weather:
# prevent-lightning-strike-blocks: []
# disable-lightning-strike-fire: false
# disable-thunderstorm: false
# disable-weather: false
# disable-pig-zombification: false
# disable-powered-creepers: false
# always-raining: false
# always-thundering: false
regions:
__global__:
type: global
priority: 0
flags: []
owners: []
members: []
inventories:
info:
- This is the inventory save file.
- DO NOT EDIT!
example:
region:
entry:
kit:
equip: []
inv: []
players:
player:
equip: []
inv: []
exit:
players:
player:
equip: []
inv: []
cache:
boolean: []
state-withTarget: []
info:
- This is the cache file. We use this file to cache individual specific events so that we can reduce the number of flag lookups later on.
- Expect it to grow to a considerable size!
#
################################################################################
#
# d R e g i o n s
#
# Flag Modules
#
# Authors: |Anthony|
# Version: 0.2
# dScript Version: 0.9.6-DEV_b140
#
#
#
#--- About this script
#
# Adding new flags /can/ be as easy as making a new module!
#
#
#
################################################################################
dRegions_Flag_Entry:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entry<&4>]"
lore:
- <&5>Who can enter a region
event_hook: regionEnter
event_priority: 0
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define player <player>
- define region '<def[orderedRegions].get[1]>'
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entry]>'
- if %flagObj% != null {
- inject s@dRegions_Flags_Processors p:state-withGroup
}
}
- run locally entered delay:1t player:<player> def:%world%|%region%|<def[orderedRegions].escaped>
event-global:
- define player <player>
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entry]>'
- if %flagObj% != null {
- inject s@dRegions_Flags_Processors p:state-withGroup-Global
}
}
- run locally entered-global delay:1t player:<player> def:%world%|__global__
entered:
- ^define world '%1%'
- ^define region '%2%'
- ^define orderedRegions '<def[3].unescaped>'
- ^define player '<player>'
- ^inject s@dRegions_Flag_Notify-Enter p:event
- ^inject s@dRegions_Flag_Greeting p:event
- ^inject s@dRegions_Flag_Inventory p:event-enter
- ^inject s@dRegions_Flag_Gamemode p:event-enter
- ^inject s@dRegions_Flag_Heal-Amount p:event
- ^inject s@dRegions_Flag_Feed-Amount p:event
entered-global:
- ^define world '%1%'
- ^define region '%2%'
- ^define player '<player>'
- ^inject s@dRegions_Flag_Notify-Enter p:event-global
- ^inject s@dRegions_Flag_Greeting p:event-global
- ^inject s@dRegions_Flag_Inventory p:event-enter
- ^inject s@dRegions_Flag_Gamemode p:event-enter
- ^inject s@dRegions_Flag_Heal-Amount p:event-global
- ^inject s@dRegions_Flag_Feed-Amount p:event-global
event-cleanup:
- if <player.is_inside_vehicle||false> {
- run locally vehicle 'def:<player.get_vehicle>|<c.from>' delay:1t
}
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You do not have permission to enter this region'
}
vehicle:
- ^if <player.has_flag[dRegions_regionKick]> {
- queue clear
}
else {
- flag <player> dRegions_regionKick d:5t
}
- ^mount cancel <player>|%1%
- ^teleport '<player>' '<def[2].above>'
- ^wait 20t
- ^adjust %1% 'velocity:l@0,0,0,<def[1].world>'
- ^teleport %1% '<t[<def[1].is_living>]:<player.location>||<def[2].above>>'
dRegions_Flag_Exit:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Exit<&4>]"
lore:
- <&5>Who can exit a region
event_hook: regionExit
event_priority: 0
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define player <player>
- define region '<def[orderedRegions].get[1]>'
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|exit]>'
- if %flagObj% != null {
- inject s@dRegions_Flags_Processors p:state-withGroup
}
}
- run locally exited delay:1t player:<player> def:%world%|%region%|<def[orderedRegions].escaped>
event-global:
- define player <player>
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|exit]>'
- if %flagObj% != null {
- inject s@dRegions_Flags_Processors p:state-withGroup-Global
}
}
- run locally exited-global delay:1t player:<player> def:%world%|__global__
exited:
- ^define world '%1%'
- ^define region '%2%'
- ^define orderedRegions '<def[3].unescaped>'
- ^define player '<player>'
- ^inject s@dRegions_Flag_Notify-Exit p:event
- ^inject s@dRegions_Flag_Farewell p:event
- ^inject s@dRegions_Flag_Inventory p:event-exit
- ^inject s@dRegions_Flag_Gamemode p:event-exit
exited-global:
- ^define world '%1%'
- ^define region '%2%'
- ^define player '<player>'
- ^inject s@dRegions_Flag_Notify-Exit p:event-global
- ^inject s@dRegions_Flag_Farewell p:event-global
- ^inject s@dRegions_Flag_Inventory p:event-Exit
- ^inject s@dRegions_Flag_Gamemode p:event-Exit
event-cleanup:
- if <player.is_inside_vehicle||false> {
- define vehicle '<player.get_vehicle>'
- run locally vehicle 'def:%vehicle%|<c.from>' delay:1t
}
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You do not have permission to exit this region'
}
vehicle:
- ^if <player.has_flag[dRegions_regionKick]> {
- queue clear
}
else {
- flag <player> dRegions_regionKick d:5t
}
- ^mount cancel <player>|%1%
- ^teleport '<player>' '<def[2].above>'
- ^wait 20t
- ^adjust %1% 'velocity:l@0,0,0,<def[1].world>'
- ^teleport %1% '<t[<def[1].is_living>]:<player.location>||<def[2].above>>'
dRegions_Flag_Notify-Enter:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Notify-Enter<&4>]"
lore:
- <&5>Send notification to marked players
event_hook: regionEnter
event_priority: 5
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: false
flag_help: Boolean flag controlling whether notifications are sent for entering this region. Set to true or false. Defaults to false.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
# We only notify for the highest priority region, but we inherit the flag value from parents.
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|notify-enter]>'
- if %flagVal% == true {
- foreach <server.list_online_players.filter[has_permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
- run player:%value% s@dRegions_Msg 'def:<&5><&o><def[player].name> entered %region% in %world%'
}
}
event-global:
# We only notify for the highest priority region, but we inherit the flag value from parents.
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|notify-enter]>'
- if %flagVal% = true {
- foreach <server.list_online_players.filter[has_permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
- run player:%value% s@dRegions_Msg 'def:<&5><&o><def[player].name> entered the global region in %world%'
}
}
dRegions_Flag_Notify-Exit:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Notify-Exit<&4>]"
lore:
- <&5>Send notification to marked players
event_hook: regionExit
event_priority: 5
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: false
flag_help: Boolean flag controlling whether notifications are sent for exiting this region. Set to true or false. Defaults to false.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
# We only notify for the highest priority region, but we inherit the flag value from parents.
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|notify-exit]>'
- if %flagVal% == true {
- foreach <server.list_online_players.filter[has_permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
- run player:%value% s@dRegions_Msg 'def:<&5><&o><def[player].name> left %region% in %world%'
}
}
event-global:
# We only notify for the highest priority region, but we inherit the flag value from parents.
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|notify-exit]>'
- if %flagVal% = true {
- foreach <server.list_online_players.filter[has_permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
- run player:%value% s@dRegions_Msg 'def:<&5><&o><def[player].name> left the global region in %world%'
}
}
dRegions_Flag_Greeting:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Greeting<&4>]"
lore:
- <&5>Message on enter region
event_hook: regionEnter
event_priority: 10
flag_type: string
flag_takeGroup: false
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
# We should only get a message from the highest priority region, but let's inherit from parents.
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|greeting]>'
- if %flagVal% != null {
# - narrate "<def[flagVal].replace[regex:&([0-9a-fA-Fk-oK-OrR])].with[<&r.before[r]>$1]>
- narrate "<parse:%flagVal%>"
- adjust <player> 'action_bar:<parse:%flagVal%>'
}
event-global:
# We should only get a message from the highest priority region, but let's inherit from parents.
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|greeting]>'
- if %flagVal% != null {
# - narrate "<def[flagVal].replace[regex:&([0-9a-fA-Fk-oK-OrR])].with[<&r.before[r]>$1]>
- narrate "<parse:%flagVal%>"
- adjust <player> 'action_bar:<parse:%flagVal%>'
}
dRegions_Flag_Farewell:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Farewell<&4>]"
lore:
- <&5>Message on exit region
event_hook: regionExit
event_priority: 10
flag_type: string
flag_takeGroup: false
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
# We should only get a message from the highest priority region, but let's inherit from parents.
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|farewell]>'
- if %flagVal% != null {
# - narrate "<def[flagVal].replace[regex:&([0-9a-fA-Fk-oK-OrR])].with[<&r.before[r]>$1]>
- narrate "<parse:%flagVal%>"
- adjust <player> 'action_bar:<parse:%flagVal%>'
}
event-global:
# We should only get a message from the highest priority region, but let's inherit from parents.
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|farewell]>'
- if %flagVal% != null {
# - narrate "<def[flagVal].replace[regex:&([0-9a-fA-Fk-oK-OrR])].with[<&r.before[r]>$1]>
- narrate "<parse:%flagVal%>"
- adjust <player> 'action_bar:<parse:%flagVal%>'
}
dRegions_Flag_Inventory:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Inventory<&4>]"
lore:
- <&5>Save inventory before going into a region
event_hook: regionToggle
event_priority: 10
flag_type: custom
flag_type_customVal: unique|kit
flag_help: Inventory flag can be set to unique or kit. Unique inventories start empty. Kit inventories use your current inventory.
flag_takeGroup: true
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- if <def[flagValue].is[==].to[kit]> {
- yaml set 'inventories.regions.%region%.entry.kit.equip:<player.equipment>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.entry.kit.inv:<player.inventory.list_contents>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.exit.players:|:' 'id:dRegions_%world%_inventories'
}
- if <def[flagValue].is[==].to[unique]> {
- yaml set 'inventories.regions.%region%.entry.players:|:' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.exit.players:|:' 'id:dRegions_%world%_inventories'
}
- if <def[flagValue].is[==].to[null]> {
- yaml set 'inventories.regions.%region%:!' 'id:dRegions_%world%_inventories'
}
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
event-enter:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|inventory]>'
- if %flagObj% != null {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|<player>]> {
- inject locally <def[flagObj].split[/].get[1]>-enter
}
}
event-exit:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|inventory]>'
- if %flagObj% != null {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|<player>]> {
- inject locally <def[flagObj].split[/].get[1]>-exit
}
}
kit-enter:
- yaml set 'inventories.regions.%region%.exit.players.<player.uuid>.equip:<player.equipment>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.exit.players.<player.uuid>.inv:<player.inventory.list_contents>' 'id:dRegions_%world%_inventories'
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- inventory clear
- inventory set 'd:<player.inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.kit.inv]||li@>'
- define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.kit.equip]||li@>'
- equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
- run s@dRegions_Msg delay:1t 'def:<&7><&o>Your inventory has been updated.'
kit-exit:
- define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<player.uuid>.equip]||li@>'
- inventory clear
- inventory set 'd:<player.inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<player.uuid>.inv]||li@>'
- equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
- yaml set 'inventories.regions.%region%.exit.players.<player.uuid>:!' 'id:dRegions_%world%_inventories'
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- run s@dRegions_Msg delay:1t 'def:<&7><&o>Your inventory has been updated.'
unique-enter:
- yaml set 'inventories.regions.%region%.exit.players.<player.uuid>.equip:<player.equipment>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.exit.players.<player.uuid>.inv:<player.inventory.list_contents>' 'id:dRegions_%world%_inventories'
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- inventory clear
- inventory set 'd:<player.inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.players.<player.uuid>.inv]||li@>'
- define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.players.<player.uuid>.equip]||li@>'
- equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
- run s@dRegions_Msg delay:1t 'def:<&7><&o>Your inventory has been updated.'
unique-exit:
- yaml set 'inventories.regions.%region%.entry.players.<player.uuid>.equip:<player.equipment>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.entry.players.<player.uuid>.inv:<player.inventory.list_contents>' 'id:dRegions_%world%_inventories'
- define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<player.uuid>.equip]||li@>'
- inventory clear
- inventory set 'd:<player.inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<player.uuid>.inv]||li@>'
- equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
- yaml set 'inventories.regions.%region%.exit.players.<player.uuid>:!' 'id:dRegions_%world%_inventories'
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- run s@dRegions_Msg delay:1t 'def:<&7><&o>Your inventory has been updated.'
dRegions_Flag_Gamemode:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Gamemode<&4>]"
lore:
- <&5>Change gamemode inside a region
event_hook: regionToggle
event_priority: 20
flag_type: custom
flag_type_customVal: creative|survival|adventure
flag_help: Gamemode flag can be set to creative, survival, or adventure
flag_takeGroup: true
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-enter:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|gamemode]>'
- if %flagObj% != null {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|<player>]> {
- define gm '<def[flagObj].split[/].get[1]>'
- if %gm% != <player.gamemode> {
- flag <player> 'dRegions_%world%_%region%_PreviousGamemode:<player.gamemode>'
- adjust <player> 'gamemode:%gm%'
- run s@dRegions_Msg delay:1t 'def:<&7><&o>Your gamemode has been updated.'
}
}
}
event-exit:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|gamemode]>'
- if %flagObj% != null {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|<player>]> {
- if <player.flag[dRegions_%world%_%region%_PreviousGamemode]||null> != <player.gamemode> {
- adjust <player> 'gamemode:<player.flag[dRegions_%world%_%region%_PreviousGamemode]||survival>'
- run s@dRegions_Msg delay:1t 'def:<&7><&o>Your gamemode has been updated.'
}
- flag <player> 'dRegions_%world%_%region%_PreviousGamemode:!'
}
}
dRegions_Flag_Build:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Build<&4>]"
lore:
- <&5>Override default build perms
event_hook: build
event_priority: 0
flag_type: state-withGroup
flag_name: Build
flag_help: By default, all members and owners can build in their regions. Setting this flag can over ride that behavior. Can be set to allow, deny, or none and accepts the -g group switch.
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
region_highestOnly: true
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
# Build is handled differently than the other flags. It checks only the HIGHEST
# priority region. It does inherit owners, members, and flags from parent regions.
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|build]>'
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
event-global:
# Build is handled differently than the other flags. It checks only the HIGHEST
# priority region. It does inherit owners, members, and flags from parent regions.
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|build]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You do not have permission to build in this region'
}
dRegions_Flag_Vehicle-Place:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Vehicle-Place<&4>]"
lore:
- <&5>Who can place vehicles
event_hook: placeVehicle
event_priority: 5
flag_type: state-withGroup
flag_help: Control who can place vehicles in a region. Takes the -g group switch.
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
region_highestOnly: true
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t 'def:<c.item.material.name.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not place %1%s here.'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|vehicle-place]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|vehicle-place]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Vehicle-Destroy:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Vehicle-Destroy<&4>]"
lore:
- <&5>Who can destroy vehicles
event_hook: destroyVehicle
event_priority: 10
flag_type: state-withGroup
flag_help: Control who can destroy vehicles in a region. Takes the -g group switch.
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
region_highestOnly: true
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t 'def:<c.vehicle.entity_type.to_lowercase.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not break %1%s here.'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|vehicle-destroy]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|vehicle-destroy]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Send-Chat:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Send-Chat<&4>]"
lore:
- <&5>Who can chat
event_hook: sendChat
event_priority: 10
flag_type: state-withGroup
flag_help: Control who can send chat in a region. Takes the -g group switch.
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
region_highestOnly: true
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not chat here.'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|send-chat]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
- foreach stop
}
}
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|send-chat]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Hunger:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Hunger<&4>]"
lore:
- <&5>Who can get hungry
event_hook: changeFood
event_priority: 10
flag_type: state-withGroup
flag_help: Control whether players will loose hunger in this region. Takes the -g group switch.
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
region_highestOnly: false
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|hunger]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
- foreach stop
}
}
event-global:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|hunger]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
dRegions_Flag_Mob-Target:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Target<&4>]"
lore:
- <&5>Can mobs target players
event_hook: ENTITY_Target_Player
event_priority: 0
flag_type: state-withTarget-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether mobs will be able to target players in this region. Defaults to allow all. Use mob-target flag to specify mob types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<c.target.flag[dRegions.cache.%world%.%value%.mob-target.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- flag %player% dRegions.rateLimit.mob-target.%target%:true d:10s
- queue clear
}
- flag %player% dRegions.rateLimit.mob-target.%target%:false d:10s
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mob-target]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- flag %player% dRegions.rateLimit.mob-target.%target%:true d:10s
- flag %player% dRegions.cache.%world%.%value%.mob-target.%target%:none
}
}
- if %flagObj% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|mob-targetlist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag %player% dRegions.rateLimit.mob-target.%target%:true d:10s
- flag %player% dRegions.cache.%world%.%thisRegion%.mob-target.%target%:true
}
else {
- flag %player% dRegions.rateLimit.mob-target.%target%:true d:10s
}
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-target]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-targetlist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag %player% dRegions.rateLimit.mob-target.%target%:true d:5s
- flag %player% dRegions.cache.%world%.__global__.mob-target.%target%:true
}
else {
- flag %player% dRegions.rateLimit.mob-target.%target%:true d:5s
- flag %player% dRegions.cache.%world%.__global__.mob-target.%target%:none
}
event-cleanup:
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- flag %player% dRegions.rateLimit.mob-target.%target%:false d:5s
- flag %player% dRegions.cache.%world%.%thisRegion%.mob-target.%target%:false
dRegions_Flag_Mob-TargetList:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Target<&4>]"
lore:
- <&5>List of mobs used by mob-targeting flag
command_entryType: mob
command_verifyEntry: <def[value].is[matches].to[entity].not>
flag_type: list
flag_parent: dRegions_Flag_Mob-Target
flag_takeGroup: false
flag_help: List flag used with mob-targeting flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Mob-Damage:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Damage<&4>]"
lore:
- <&5>Can mobs damage players
event_hook: ENTITY_Damage_Player
event_priority: 10
flag_type: state-withTarget-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether mobs will be able to damage players in this region. Defaults to allow all. Use mob-damagelist flag to specify mob types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<c.entity.flag[dRegions.cache.%world%.%value%.mob-damage.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
- queue clear
}
- flag %player% dRegions.rateLimit.mob-damage.%target%:false d:10s
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mob-damage]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
- flag %player% dRegions.cache.%world%.%value%.mob-damage.%target%:none
}
}
- if %flagObj% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|mob-damagelist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
- flag %player% dRegions.cache.%world%.%thisRegion%.mob-damage.%target%:true
}
else {
- flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
}
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-damage]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-damagelist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
- flag %player% dRegions.cache.%world%.__global__.mob-damage.%target%:true
}
else {
- flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
- flag %player% dRegions.cache.%world%.__global__.mob-damage.%target%:none
}
event-cleanup:
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- flag %player% dRegions.rateLimit.mob-damage.%target%:false d:10s
- flag %player% dRegions.cache.%world%.%thisRegion%.mob-damage.%target%:false
dRegions_Flag_Mob-Damagelist:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-DamageList<&4>]"
lore:
- <&5>List of mobs used by mob-damage flag
command_entryType: mob
command_verifyEntry: <def[value].is[matches].to[entity].not>
flag_type: list
flag_parent: dRegions_Flag_Mob-Damage
flag_takeGroup: false
flag_help: List flag used with mob-damage flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Mob-Spawn:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Spawn<&4>]"
lore:
- <&5>Can mobs Spawn
event_hook: ENTITY_Spawn
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether mobs will be able to spawn in this region. Defaults to allow all. Use mob-spawnlist flag to specify mob types.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.mob-spawn.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mob-spawn]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.mob-spawn.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|mob-spawnlist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.mob-spawn.%target%:true' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-spawn]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-spawnlist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.mob-spawn.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.mob-spawn.%target%:none' 'id:dRegions_%world%_cache'
}
event-cleanup:
- yaml set 'cache.state-withTarget.%region%.mob-spawn.%target%:false' 'id:dRegions_%world%_cache'
dRegions_Flag_Mob-SpawnList:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Spawnlist<&4>]"
lore:
- <&5>List of mobs used by mob-spawn flag
command_entryType: mob
command_verifyEntry: <def[value].is[matches].to[entity].not>
flag_type: list
flag_parent: dRegions_Flag_Mob-Spawn
flag_takeGroup: false
flag_help: List flag used with mob-spawn flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_EVE:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>EVE<&4>]"
lore:
- <&5>Can mobs be targeted
event_hook: ENTITY_Target_ENTITY
event_priority: 20
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether mobs can be targeted for attack by other mobs in this region. Defaults to allow. Use eve-moblist flag to specify mob types.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
# event:
# - foreach %orderedRegions% {
# - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|eve]>'
# - define region '%value%'
# - if %flagVal% != null {
# - foreach stop
# }
# }
# - if %flagVal% != null {
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|eve-moblist].replace[, ].with[|].as_list>'
# - define target '%dtarget%'
# - inject s@dRegions_Flags_Processors p:state-withTarget
# }
# event-global:
# - define orderedRegions 'li@__global__'
# - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve]>'
# - if %flagVal% != null {
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve-moblist].replace[, ].with[|].as_list>'
# - define target '%dtarget%'
# - inject s@dRegions_Flags_Processors p:state-withTarget
# }
# event-cleanup:
# - remove <c.projectile||li@>
# - attack %attacker% target:cancel
event:
- define target '%dtarget%'
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.eve.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- run locally wander delay:1t def:%attacker%
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|eve]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.eve.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|eve-moblist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.eve.%target%:true' 'id:dRegions_%world%_cache'
}
# event-global:
# - define target '%dtarget%'
# - define region '__global__'
# - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve]>'
# - if %flagVal% != null {
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve-moblist].replace[, ].with[|].as_list>'
# - inject s@dRegions_Flags_Processors p:state-withTarget
# }
# - yaml set 'cache.state-withTarget.__global__.eve.%target%:true' 'id:dRegions_%world%_cache'
event-global:
- define target '%dtarget%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.eve.%target%]||null>'
- if %cache% == false {
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- run locally wander delay:1t def:%attacker%
- determine cancelled
}
- if %cache% == null {
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve-moblist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.eve.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.eve.%target%:none' 'id:dRegions_%world%_cache'
}
}
event-cleanup:
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- run locally wander delay:1t def:%attacker%
- yaml set 'cache.state-withTarget.%region%.eve.%target%:false' 'id:dRegions_%world%_cache'
wander:
- ^if !<def[1].is_spawned||false> queue clear
- ^adjust %1% toggle_ai:false
- ^walk %1% <def[1].location.find.surface_blocks.within[10].filter[distance[<def[1].location.standing_on>].vertical.is[less].than[3]].filter[distance[<def[1].location>].horizontal.is[more].than[4]].random.add[0,1,0]>
- ^wait 10s
- ^if !<def[1].is_spawned||false> queue clear
- ^adjust %1% toggle_ai:true
dRegions_Flag_EVE-Moblist:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>EVE-Moblist<&4>]"
lore:
- <&5>List of mobs used by eve flag
command_entryType: mob
command_verifyEntry: <def[value].is[matches].to[entity].not>
flag_type: list
flag_parent: dRegions_Flag_EVE
flag_takeGroup: false
flag_help: List flag used with eve flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Mob-Attack:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Attack<&4>]"
lore:
- <&5>Can mobs attack other mobs
event_hook: ENTITY_Target_ENTITY
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether mobs can attack other mobs in this region. Defaults to allow. Use mob-attack-moblist flag to specify mob types.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define target '%atarget%'
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.mob-attack.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- define flagVal 'null'
- foreach stop
}
- run locally wander delay:1t def:%attacker%
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mob-attack]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.mob-attack.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|mob-attack-moblist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.mob-attack.%target%:true' 'id:dRegions_%world%_cache'
}
event-global:
- define target '%atarget%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.mob-attack.%target%]||null>'
- if %cache% == false {
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- run locally wander delay:1t def:%attacker%
- determine cancelled
}
- if %cache% == null {
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-attack]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-attack-moblist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.mob-attack.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.mob-attack.%target%:none' 'id:dRegions_%world%_cache'
}
}
event-cleanup:
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- run locally wander delay:1t def:%attacker%
- yaml set 'cache.state-withTarget.%region%.mob-attack.%target%:false' 'id:dRegions_%world%_cache'
wander:
- ^if !<def[1].is_spawned||false> queue clear
- ^adjust %1% toggle_ai:false
- ^walk %1% <def[1].location.find.surface_blocks.within[10].filter[distance[<def[1].location.standing_on>].vertical.is[less].than[3]].filter[distance[<def[1].location>].horizontal.is[more].than[4]].random.add[0,1,0]>
- ^wait 10s
- ^if !<def[1].is_spawned||false> queue clear
- ^adjust %1% toggle_ai:true
dRegions_Flag_Mob-Attack-Moblist:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Attack-Moblist<&4>]"
lore:
- <&5>List of mobs used by mob-attack flag
command_entryType: mob
command_verifyEntry: <def[value].is[matches].to[entity].not>
flag_type: list
flag_parent: dRegions_Flag_Mob-Attack
flag_takeGroup: false
flag_help: List flag used with mob-attack flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_PVE:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>PVE<&4>]"
lore:
- <&5>Can players damage mobs
event_hook: PLAYER_Damage_Entity
event_priority: 10
flag_type: state-withTarget-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether players will be able to damage mobs in this region. Defaults to allow all. Use pve-moblist flag to specify mob types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.pve.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- flag <player> dRegions.rateLimit.pve.%target%:true d:10s
- queue clear
}
- flag <player> dRegions.rateLimit.pve.%target%:false d:10s
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|pve]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- flag <player> dRegions.rateLimit.pve.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%value%.pve.%target%:none
}
}
- if %flagObj% != null {
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|pve-moblist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag <player> dRegions.rateLimit.pve.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.pve.%target%:true
}
else {
- flag <player> dRegions.rateLimit.pve.%target%:true d:10s
}
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|pve]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|pve-moblist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag <player> dRegions.rateLimit.pve.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.pve.%target%:true
}
else {
- flag <player> dRegions.rateLimit.pve.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.pve.%target%:none
}
event-cleanup:
- remove <c.projectile||li@>
- flag <player> dRegions.rateLimit.pve.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.pve.%target%:false
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not attack %1%s here!'
}
dRegions_Flag_PVE-Moblist:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>PVE-Moblist<&4>]"
lore:
- <&5>List of mobs used by pve flag
command_entryType: mob
command_verifyEntry: <def[value].is[matches].to[entity].not>
flag_type: list
flag_parent: dRegions_Flag_PVE
flag_takeGroup: false
flag_help: List flag used with pve flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Npc-Interact:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>NPC Interact<&4>]"
lore:
- <&5>Can players interact with NPCs
event_hook: npc-interact
event_priority: 10
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether players will be able to interact with NPCs in this region. Defaults to allow. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define region '%value%'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|npc-interact]>'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|npc-interact]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
event-cleanup:
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not interact with NPCs here!'
}
dRegions_Flag_Entity-Interact:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity Interact<&4>]"
lore:
- <&5>Can players interact with entities
event_hook: entity-interact
event_priority: 10
flag_type: state-withTarget-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether players will be able to interact with entities in this region. Defaults to allow all. Use entity-interactlist flag to specify entity types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.entity-interact.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
- queue clear
}
- flag <player> dRegions.rateLimit.entity-interact.%target%:false d:10s
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-interact]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%value%.entity-interact.%target%:none
}
}
- if %flagObj% != null {
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entity-interactlist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.entity-interact.%target%:true
}
else {
- flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
}
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-interact]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-interactlist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.entity-interact.%target%:true
}
else {
- flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.entity-interact.%target%:none
}
event-cleanup:
- flag <player> dRegions.rateLimit.entity-interact.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.entity-interact.%target%:false
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not interact with %1%s here!'
}
dRegions_Flag_Entity-Interactlist:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity Interact List<&4>]"
lore:
- <&5>List of entities used by entity-interact flag
command_entryType: mob
command_verifyEntry: <def[value].is[matches].to[entity].not>
flag_type: list
flag_parent: dRegions_Flag_Entity-Interact
flag_takeGroup: false
flag_help: List flag used with entity-interact flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of entities.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Entity-Explode:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Explode<&4>]"
lore:
- <&5>Can entities explode
event_hook: entity-explode
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether entities will be able to explode in this region. Defaults to allow all. Use entity-explodelist flag to specify entities types.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.entity-explode.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-explode]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.entity-explode.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entity-explodelist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.entity-explode.%target%:true' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-explode]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-explodelist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.entity-explode.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.entity-explode.%target%:none' 'id:dRegions_%world%_cache'
}
event-cleanup:
- yaml set 'cache.state-withTarget.%region%.entity-explode.%target%:false' 'id:dRegions_%world%_cache'
dRegions_Flag_Entity-ExplodeList:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Explodelist<&4>]"
lore:
- <&5>List of mobs used by entity-explode flag
command_entryType: entity
command_verifyEntry: <el@val[creeper|ender_crystal|ender_dragon|primed_tnt|minecart_tnt|fireball|small_fireball|wither|wither_skull].as_list.contains[<def[value]>].not>
flag_type: list
flag_parent: dRegions_Flag_Entity-Explode
flag_takeGroup: false
flag_help: List flag used with entity-explode flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of entities. Valid entities<&co> creeper, ender_crystal, ender_dragon, primed_tnt, minecart_tnt, fireball, small_fireball, wither, wither_skull
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Entity-Grief:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Grief<&4>]"
lore:
- <&5>Can entities alter blocks
event_hook: entity-changeBlock
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether entities will be able to alter blocks in this region. Defaults to allow all. Use entity-grieflist flag to specify entities types.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.entity-grief.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- run locally offthread delay:1t def:<c.entity.uuid>
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-grief]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.entity-grief.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entity-grieflist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.entity-grief.%target%:true' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-grief]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-grieflist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.entity-grief.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.entity-grief.%target%:none' 'id:dRegions_%world%_cache'
}
event-cleanup:
- yaml set 'cache.state-withTarget.%region%.entity-grief.%target%:false' 'id:dRegions_%world%_cache'
- run locally offthread delay:1t def:<c.entity.uuid>
offthread:
- ^flag server dRegions.EntityGrief.%1%
- ^wait 3s
- ^flag server dRegions.EntityGrief.%1%:!
dRegions_Flag_Entity-GriefList:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Grieflist<&4>]"
lore:
- <&5>List of mobs used by entity-grief flag
command_entryType: entity
command_verifyEntry: <el@val[enderman|sheep|zombie|squid].as_list.contains[<def[value]>].not>
flag_type: list
flag_parent: dRegions_Flag_Entity-Grief
flag_takeGroup: false
flag_help: List flag used with entity-grief flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of entities. Valid entities<&co> sheep, enderman, zombie, squid
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Entity-Drops-OnDeath:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Drops-OnDeath<&4>]"
lore:
- <&5>Can mobs drop items
event_hook: EntityDies
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.entity-drops-ondeath.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine no_drops
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-drops-ondeath]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.entity-drops-ondeath.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entity-drops-ondeathlist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.entity-drops-ondeath.%target%:true' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-drops-ondeath]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-drops-ondeathlist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.entity-drops-ondeath.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.entity-drops-ondeath.%target%:none' 'id:dRegions_%world%_cache'
}
event-cleanup:
- yaml set 'cache.state-withTarget.%region%.entity-drops-ondeath.%target%:false' 'id:dRegions_%world%_cache'
- determine no_drops
dRegions_Flag_Entity-Drops-OnDeathList:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Drops-OnDeathlist<&4>]"
lore:
- <&5>List of mobs used by entity-drops-ondeath flag
command_entryType: entity
command_verifyEntry: <def[value].is[matches].to[entity].not>
flag_type: list
flag_parent: dRegions_Flag_Entity-Drops-OnDeath
flag_takeGroup: false
flag_help: List flag used with entity-drops-ondeath flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of entities.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Fire-Spread:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Fire-Spread<&4>]"
lore:
- <&5>Can fire spread
event_hook: fireFrom-Spread
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether fire will be able to spread in this region. Defaults to allow all. Use fire-spreadblocks flag to specify blocks to check when spreading.
# flag_help: This flag is temporarily disabled. Please use the fire-destroyblocks flag.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.fire-spread.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|fire-spread]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.fire-spread.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|fire-spreadblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.fire-spread.%target%:true' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|fire-spread]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|fire-spreadblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.fire-spread.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.fire-spread.%target%:none' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Fire-SpreadBlocks:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Fire-Spread-BlockList<&4>]"
lore:
- <&5>List of blocks involved in fire spread
command_entryType: block
command_verifyEntry: <def[value].as_material.is_block.not||true>
flag_type: list
flag_parent: dRegions_Flag_Fire-Spread
flag_takeGroup: false
flag_help: List flag used with fire-spread flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Fire-Destroy:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Fire-Destroy<&4>]"
lore:
- <&5>Can fire destroy blocks
event_hook: fire-destroyBlocks
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether fire will be able to spread to and destroy blocks in this region. Defaults to allow all. Use fire-destroyblocks flag to specify blocks to check when spreading.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.fire-destroy.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- define flagVal 'null'
- foreach stop
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|fire-destroy]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.fire-destroy.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|fire-destroyblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.fire-destroy.%target%:true' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|fire-destroy]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|fire-destroyblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.fire-destroy.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.fire-destroy.%target%:none' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Fire-DestroyBlocks:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Fire-Destroy-BlockList<&4>]"
lore:
- <&5>List of blocks involved in fire-destroy
command_entryType: block
command_verifyEntry: <def[value].as_material.is_block.not||true>
flag_type: list
flag_parent: dRegions_Flag_Fire-Destroy
flag_takeGroup: false
flag_help: List flag used with fire-destroy flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Lightning-Strikes:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Lightning-Strikes<&4>]"
lore:
- <&5>Can lightning strike
event_hook: lightning-strikes
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether lightning will be able to strike in this region. Defaults to allow all. Use lightning-strikeblocks flag to specify blocks to check when striking.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.lightning-strikes.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|lightning-strikes]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.lightning-strikes.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|lightning-strikesblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.lightning-strikes.%target%:true' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lightning-strikes]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lightning-strikesblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.lightning-strikes.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.lightning-strikes.%target%:none' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Lightning-StrikesBlocks:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Lightning-StrikesBlocks<&4>]"
lore:
- <&5>List of blocks involved in lightning strikes
command_entryType: block
command_verifyEntry: <def[value].as_material.is_block.not||true>
flag_type: list
flag_parent: dRegions_Flag_Lightning-Strikes
flag_takeGroup: false
flag_help: List flag used with lightning-strike flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Water-Spread:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Water-Spread<&4>]"
lore:
- <&5>Can Water spread
event_hook: WaterSpread
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether water will be able to spread in this region. Defaults to allow all. Use water-spreadblocks flag to specify blocks to check when spreading.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.water-spread.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|water-spread]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.water-spread.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|water-spreadblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.water-spread.%target%:true' 'id:dRegions_%world%_cache'
- queue clear
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|water-spread]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|water-spreadblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.water-spread.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.water-spread.%target%:none' 'id:dRegions_%world%_cache'
}
event-cleanup:
- yaml set 'cache.state-withTarget.%region%.water-spread.%target%:false' 'id:dRegions_%world%_cache'
- queue clear
dRegions_Flag_Water-SpreadBlocks:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Water-Spread-BlockList<&4>]"
lore:
- <&5>List of blocks involved in water spread
command_entryType: block
command_verifyEntry: <def[value].as_material.is_block.not||true>
flag_type: list
flag_parent: dRegions_Flag_Water-Spread
flag_takeGroup: false
flag_help: List flag used with water-spread flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Lava-Spread:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Lava-Spread<&4>]"
lore:
- <&5>Can Lava spread
event_hook: LavaSpread
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether lava will be able to spread in this region. Defaults to allow all. Use lava-spreadblocks flag to specify blocks to check when spreading.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
# event:
# - foreach %orderedRegions% {
# - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|lava-spread]>'
# - define region '%value%'
# - if %flagVal% != null {
# - foreach stop
# }
# }
# - if %flagVal% != null {
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|lava-spreadblocks].replace[, ].with[|].as_list>'
# - inject s@dRegions_Flags_Processors p:state-withTarget
# }
# event-global:
# - define orderedRegions 'li@__global__'
# - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lava-spread]>'
# - if %flagVal% != null {
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lava-spreadblocks].replace[, ].with[|].as_list>'
# - inject s@dRegions_Flags_Processors p:state-withTarget
# }
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.lava-spread.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|lava-spread]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.lava-spread.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|lava-spreadblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.lava-spread.%target%:true' 'id:dRegions_%world%_cache'
- queue clear
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lava-spread]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lava-spreadblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.lava-spread.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.lava-spread.%target%:none' 'id:dRegions_%world%_cache'
}
event-cleanup:
- yaml set 'cache.state-withTarget.%region%.lava-spread.%target%:false' 'id:dRegions_%world%_cache'
dRegions_Flag_Lava-SpreadBlocks:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Lava-Spread-BlockList<&4>]"
lore:
- <&5>List of blocks involved in lava spread
command_entryType: block
command_verifyEntry: <def[value].as_material.is_block.not||true>
flag_type: list
flag_parent: dRegions_Flag_Lava-Spread
flag_takeGroup: false
flag_help: List flag used with lava-spread flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Snow-Fall:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Snow-Fall<&4>]"
lore:
- <&5>Can Snow accumulate
event_hook: blockForm-snow
event_priority: 10
flag_type: state-withTarget
flag_takeGroup: false
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether snow will be able to accumulate on the ground in this region. Defaults to allow all. Use snow-fallblocks flag to specify blocks below the snow to check when forming.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define region '%value%'
- define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.snow-fall.%target%]||null>'
- if %cache% == none {
- define flagVal 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|snow-fall]>'
- if %flagVal% != null {
- foreach stop
}
else {
- yaml set 'cache.state-withTarget.%region%.snow-fall.%target%:none' 'id:dRegions_%world%_cache'
}
}
- if %flagVal% != null {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|snow-fallblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.%region%.snow-fall.%target%:true' 'id:dRegions_%world%_cache'
- queue clear
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|snow-fall]>'
- if %flagVal% != null {
- define region '__global__'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|snow-fallblocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget
- yaml set 'cache.state-withTarget.__global__.snow-fall.%target%:true' 'id:dRegions_%world%_cache'
}
else {
- yaml set 'cache.state-withTarget.__global__.snow-fall.%target%:none' 'id:dRegions_%world%_cache'
}
event-cleanup:
- yaml set 'cache.state-withTarget.%region%.snow-fall.%target%:false' 'id:dRegions_%world%_cache'
dRegions_Flag_Snow-FallBlocks:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Snow-Fall-BlockList<&4>]"
lore:
- <&5>List of blocks to check under snow
command_entryType: block
command_verifyEntry: <def[value].as_material.is_block.not||true>
flag_type: list
flag_parent: dRegions_Flag_Snow-Fall
flag_takeGroup: false
flag_help: List flag used with snow-fall flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Ice-Form:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Ice-Form<&4>]"
lore:
- <&5>Can water turn into ice
event_hook: blockForm-ice
event_priority: 10
flag_type: boolean
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether water will be able to turn into ice in this region. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.ice-form]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|ice-form]>'
- if %flagVal% != null {
- if %flagVal% {
- yaml set 'cache.boolean.%value%.ice-form:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.ice-form:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.ice-form:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|ice-form]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.ice-form:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
}
- yaml set 'cache.boolean.__global__.ice-form:true' 'id:dRegions_%world%_cache'
dRegions_Flag_Ice-Melt:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Ice-Melt<&4>]"
lore:
- <&5>Can ice melt
event_hook: blockFade-ice
event_priority: 10
flag_type: boolean
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether ice can melt in this region. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.ice-melt]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|ice-melt]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.ice-melt:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.ice-melt:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.ice-melt:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|ice-melt]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.ice-melt:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
}
- yaml set 'cache.boolean.__global__.ice-melt:true' 'id:dRegions_%world%_cache'
dRegions_Flag_Snow-Melt:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Snow-Melt<&4>]"
lore:
- <&5>Can snow melt
event_hook: blockFade-snow
event_priority: 10
flag_type: boolean
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether snow can melt in this region. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.snow-melt]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|snow-melt]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.snow-melt:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.snow-melt:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.snow-melt:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|snow-melt]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.snow-melt:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
}
- yaml set 'cache.boolean.__global__.snow-melt:true' 'id:dRegions_%world%_cache'
dRegions_Flag_Soil-Dry:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Soil-Dry<&4>]"
lore:
- <&5>Can soil dry up
event_hook: blockFade-soil
event_priority: 10
flag_type: boolean
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether soil can dry in this region. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.soil-dry]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|soil-dry]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.soil-dry:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.soil-dry:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.soil-dry:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|soil-dry]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.soil-dry:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.soil-dry:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Trample-Crops-Player:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Trample-Crops-Player<&4>]"
lore:
- <&5>Can players trample crops
event_hook: trample-crops-player
event_priority: 10
flag_type: boolean
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether players can trample crops in this region. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.trample-crops-player]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|trample-crops-player]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.trample-crops-player:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.trample-crops-player:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.trample-crops-player:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|trample-crops-player]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.trample-crops-player:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.trample-crops-player:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Trample-Crops-Entity:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Trample-Crops-Entity<&4>]"
lore:
- <&5>Can entities trample crops
event_hook: trample-crops-entity
event_priority: 10
flag_type: boolean
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether entities can trample crops in this region. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.trample-crops-entity]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|trample-crops-entity]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.trample-crops-entity:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.trample-crops-entity:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.trample-crops-entity:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|trample-crops-entity]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.trample-crops-entity:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.trample-crops-entity:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Mushroom-Spread:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mushroom-Spread<&4>]"
lore:
- <&5>Can Mushrooms spread
event_hook: MushroomSpread
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether mushrooms will be able to spread in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.mushroom-spread]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mushroom-spread]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.mushroom-spread:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.mushroom-spread:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.mushroom-spread:none' 'id:dRegions_%world%_cache'
}
event-Global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mushroom-spread]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.mushroom-spread:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.mushroom-spread:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Grass-Spread:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Grass-Spread<&4>]"
lore:
- <&5>Can Grass spread
event_hook: GrassSpread
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether grass will be able to spread in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.grass-spread]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|grass-spread]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.grass-spread:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.grass-spread:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.grass-spread:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|grass-spread]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.grass-spread:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.grass-spread:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Mycel-Spread:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Mycel-Spread<&4>]"
lore:
- <&5>Can Mycelium spread
event_hook: MycelSpread
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether mycelium will be able to spread in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.mycel-spread]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mycel-spread]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.mycel-spread:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.mycel-spread:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.mycel-spread:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mycel-spread]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.mycel-spread:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.mycel-spread:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Vines-Spread:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Vine-Growth<&4>]"
lore:
- <&5>Can Vines grow
event_hook: VinesSpread
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether vines will be able to grow in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.vines-spread]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|vines-spread]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.vines-spread:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.vines-spread:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.vines-spread:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|vines-spread]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.vines-spread:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.vines-spread:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Leaf-Decay:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Leaf-Decay<&4>]"
lore:
- <&5>Can leaves decay
event_hook: leaf-decay
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether leaves will be able to decay in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.leaf-decay]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|leaf-decay]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.leaf-decay:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.leaf-decay:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.leaf-decay:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|leaf-decay]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.leaf-decay:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.leaf-decay:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Falling-Sand:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Falling-Sand<&4>]"
lore:
- <&5>Can sand fall
event_hook: physics-sand
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether sand will be able to fall in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.falling-sand]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|falling-sand]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.falling-sand:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.falling-sand:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.falling-sand:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|falling-sand]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.falling-sand:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.falling-sand:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Falling-Gravel:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Falling-Gravel<&4>]"
lore:
- <&5>Can gravel fall
event_hook: physics-gravel
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether gravel will be able to fall in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.falling-gravel]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|falling-gravel]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.falling-gravel:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.falling-gravel:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.falling-gravel:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|falling-gravel]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.falling-gravel:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.falling-gravel:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Pistons:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Pistons<&4>]"
lore:
- <&5>Can pistons be activated
event_hook: pistons
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether pistons can be activated in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.pistons]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|pistons]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.pistons:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.pistons:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.pistons:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|pistons]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.pistons:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.pistons:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Lighter:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Lighter<&4>]"
lore:
- <&5>Who can use the flint and steel in a region
event_hook: fireFrom-Lighter
event_priority: 10
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not use a lighter in this region'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|lighter]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lighter]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Bucket-Fill:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Bucket-Fill<&4>]"
lore:
- <&5>Who can fill a bucket in a region
event_hook: fillBucket
event_priority: 5
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not fill a bucket in this region'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|bucket-fill]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|bucket-fill]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Bucket-Empty:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Bucket-Empty<&4>]"
lore:
- <&5>Who can fill a bucket in a region
event_hook: emptyBucket
event_priority: 5
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not empty a bucket in this region'
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|bucket-empty]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|bucket-empty]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
dRegions_Flag_Hanging-Place:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Hanging-Place<&4>]"
lore:
- <&5>Who can place item frames and paintings
event_hook: hangingPlace
event_priority: 0
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not hang that in this region'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|hanging-place]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|hanging-place]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Hanging-Break:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Hanging-Break<&4>]"
lore:
- <&5>Who can break item frames and paintings
event_hook: hangingBreak
event_priority: 0
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not break that in this region'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|hanging-break]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|hanging-break]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Sleep:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Sleep<&4>]"
lore:
- <&5>Who can Sleep
event_hook: sleep
event_priority: 10
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not sleep here.'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|sleep]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|sleep]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Player-Drops:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Drops<&4>]"
lore:
- <&5>Who can drop items
event_hook: player-drop
event_priority: 10
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not drop items here.'
}
event:
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-drops]>'
- define region '%value%'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
- foreach stop
}
}
event-global:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-drops]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
dRegions_Flag_Player-Drops-OnDeath:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Drops-OnDeath<&4>]"
lore:
- <&5>Who can drop items when they die
event_hook: PlayerDies
event_priority: 20
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- determine NO_DROPS
event:
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-drops-ondeath]>'
- define region '%value%'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
- foreach stop
}
}
event-global:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-drops-ondeath]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
dRegions_Flag_Player-KeepItems:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Player-KeepItems<&4>]"
lore:
- <&5>Can players keep items on death
event_hook: PlayerDies
event_priority: 10
flag_type: state
flag_takeGroup: true
flag_defaultValue: deny/all
flag_help: State flag controlling whether players will keep their items when they die in a region. Default is to deny all. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-keepitems]>'
- if %flagObj% != null {
- if <def[flagObj].split[/].get[1]> == allow {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%value%|%world%|<player>]> {
- run locally returnItems 'def:<player.inventory.list_contents.escaped>|<player.equipment.escaped>' delay:2t
- determine NO_DROPS_NO_XP
- foreach stop
}
}
else {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%value%|%world%|<player>]> {
- run locally returnItems 'def:<player.inventory.list_contents.escaped>|<player.equipment.escaped>' delay:2t
- determine NO_DROPS_NO_XP
- foreach stop
}
}
}
}
event-global:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-keepitems]>'
- if %flagObj% != null {
- if <def[flagObj].split[/].get[1]> == allow {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|<player>]> {
- run locally returnItems 'def:<player.inventory.list_contents.escaped>|<player.equipment.escaped>' delay:2t
- determine NO_DROPS_NO_XP
}
}
else {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|<player>]> {
- run locally returnItems 'def:<player.inventory.list_contents.escaped>|<player.equipment.escaped>' delay:2t
- determine NO_DROPS_NO_XP
}
}
}
returnItems:
- inventory clear
- run s@dRegions_Msg delay:1t 'def:<&9>You died, but your inventory is safe!'
- inventory set 'd:<player.inventory>' 'o:<def[1].unescaped>'
- define equipment '<def[2].unescaped>'
- equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
dRegions_Flag_Spawn:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Spawn<&4>]"
lore:
- <&5>Region spawn point.
event_hook: playerDies
event_priority: 5
flag_type: location
flag_takeGroup: true
flag_help: Set the location players will respawn at if they die in this region. Default is to have no effect so normal respawn mechanics will apply. Takes the -g group switch. Specify the value as `here` to use your current location, or specify a valid location in the `x,y,z,world` format.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_RegionOverlaps].context[<def[flagValue]>/<def[flagValue]>|%world%|<player>]> {
- run s@dRegions_Msg delay:1t 'def:<&c>You can not use that location!'
- queue clear
}
}
event:
- ^foreach <def[2].unescaped> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%1%|%value%|spawn]>'
- if ( %flagObj% != null ) && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%value%|%1%|<player>]> {
# - adjust <player> 'location:<def[flagObj].split[/].get[1].as_location>'
- flag <player> 'dRegions_Respawn:<def[flagObj].split[/].get[1].as_location>'
- foreach stop
}
}
event-global:
- ^define flagObj '<proc[dRegions_GetInheritedFlag].context[%1%|__global__|spawn]>'
- ^if ( %flagObj% != null ) && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%1%|<player>]> {
# - adjust <player> 'location:<def[flagObj].split[/].get[1].as_location>'
- flag <player> 'dRegions_Respawn:<def[flagObj].split[/].get[1].as_location>'
}
dRegions_Flag_Player-Pickup:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Pickup<&4>]"
lore:
- <&5>Who can pickup items
event_hook: player-pickup
event_priority: 10
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not pick up items here.'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-pickup]>'
- define region '%value%'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
- foreach stop
}
}
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-pickup]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Entity-Break-Painting:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Break-Painting<&4>]"
lore:
- <&5>Can Entities break paintings
event_hook: entity-break-painting
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether mobs will be able to destroy paintings in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.entity-break-painting]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-break-painting]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.entity-break-painting:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.entity-break-painting:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.entity-break-painting:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-break-painting]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.entity-break-painting:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.entity-break-painting:none' 'id:dRegions_%world%_cache'
}
dRegions_Flag_Entity-Break-ItemFrame:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Break-ItemFrame<&4>]"
lore:
- <&5>Can Entities break item frames
event_hook: entity-break-itemframe
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether mobs will be able to destroy item frames in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.entity-break-itemframe]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-break-itemframe]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.entity-break-itemframe:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.entity-break-itemframe:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.entity-break-itemframe:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-break-itemframe]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.entity-break-itemframe:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.entity-break-itemframe:true' 'id:dRegions_%world%_cache'
}
dRegions_Flag_PVP:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>PVP<&4>]"
lore:
- <&5>Can players damage each other
event_hook: player_damage_player
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether players can attack eachother in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.pvp]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- remove <c.projectile||li@>
- run locally msg delay:1t
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|pvp]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.%value%.pvp:false' 'id:dRegions_%world%_cache'
- remove <c.projectile||li@>
- run locally msg delay:1t
- determine cancelled
}
- yaml set 'cache.boolean.%value%.pvp:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.pvp:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|pvp]>'
- if %flagVal% != null {
- if !%flagVal% {
- yaml set 'cache.boolean.__global__.pvp:false' 'id:dRegions_%world%_cache'
- remove <c.projectile||li@>
- run locally msg delay:1t
- determine cancelled
}
- yaml set 'cache.boolean.__global__.pvp:true' 'id:dRegions_%world%_cache'
}
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You are in a no PVP zone.'
}
dRegions_Flag_Potion-Throw:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Potion-Throw<&4>]"
lore:
- <&5>Can potions be thrown in this region
event_hook: throwPotion
event_priority: 10
flag_type: boolean
flag_takeGroup: false
flag_defaultValue: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether potions can be thrown and broken in this region. Set to true or false. Defaults to true.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- foreach %orderedRegions% {
- define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.potion-throw]||null>'
- if %cache% == none {
- foreach next
}
- if %cache% != null {
- if %cache% {
- queue clear
}
- if <player.is[!=].to[null]||false> {
- run locally msg delay:1t
}
- determine cancelled
}
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|potion-throw]>'
- if %flagVal% != null {
- if !%flagVal% {
- if <player.is[!=].to[null]||false> {
- run locally msg delay:1t
}
- yaml set 'cache.boolean.%value%.potion-throw:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.%value%.potion-throw:true' 'id:dRegions_%world%_cache'
- foreach stop
}
- yaml set 'cache.boolean.%value%.potion-throw:none' 'id:dRegions_%world%_cache'
}
event-global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|potion-throw]>'
- if %flagVal% != null {
- if !%flagVal% {
- if <player.is[!=].to[null]||false> {
- run locally msg delay:1t
}
- yaml set 'cache.boolean.__global__.potion-throw:false' 'id:dRegions_%world%_cache'
- determine cancelled
}
- yaml set 'cache.boolean.__global__.potion-throw:true' 'id:dRegions_%world%_cache'
}
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not||false> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not throw potions here.'
}
dRegions_Flag_Potion-Drink:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Potion-Drink<&4>]"
lore:
- <&5>Who can drink potions
event_hook: drinkPotion
event_priority: 10
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not drink potions here.'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|potion-drink]>'
- define region '%value%'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
- foreach stop
}
}
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|potion-drink]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Enderpearl:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Enderpearl<&4>]"
lore:
- <&5>Who can use enderpearls
event_hook: enderPearl
event_priority: 10
flag_type: state-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event-cleanup:
- run locally msg delay:1t
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not use enderpearls here.'
}
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|enderpearl]>'
- define region '%value%'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup
- foreach stop
}
}
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|enderpearl]>'
- if %flagObj% != null {
- define player <player>
- inject s@dRegions_Flags_Processors p:state-withGroup-global
}
}
dRegions_Flag_Block-Place:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Block-Place<&4>]"
lore:
- <&5>Can players place blocks.
event_hook: blockPlace
event_priority: 5
flag_type: state-withTarget-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
region_highestOnly: true
flag_help: State flag controlling whether players will be able to place blocks in this region. Defaults to allow all. Use block-placelist flag to specify block types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.block-place.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
- queue clear
}
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:false d:10s
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|block-place]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%value%.block-place.%target%:none
}
}
- if %flagObj% != null {
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|block-placelist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.block-place.%target%:true
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
}
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|block-place]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|block-placelist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.block-place.%target%:true
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.block-place.%target%:none
}
event-cleanup:
- if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.block-place.%target%:false
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not place %1% in this region!'
}
dRegions_Flag_Block-PlaceList:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Block-PlaceList<&4>]"
lore:
- <&5>List of blocks used by block-place flag
command_entryType: block
command_verifyEntry: <def[value].as_material.is_block.not||true>
flag_type: list
flag_parent: dRegions_Flag_Block-Place
flag_takeGroup: false
flag_help: List flag used with block-place flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Block-Break:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Block-Break<&4>]"
lore:
- <&5>Can players break blocks.
event_hook: blockBreak
event_priority: 5
flag_type: state-withTarget-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
region_highestOnly: true
flag_help: State flag controlling whether players will be able to break blocks in this region. Defaults to allow all. Use block-breaklist flag to specify block types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.block-break.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
- queue clear
}
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:false d:10s
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|block-break]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%value%.block-break.%target%:none
}
}
- if %flagObj% != null {
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|block-breaklist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.block-break.%target%:true
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
}
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|block-break]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|block-breaklist].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.block-break.%target%:true
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.block-break.%target%:none
}
event-cleanup:
- if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.block-break.%target%:false
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not break %1% in this region!'
}
dRegions_Flag_Block-BreakList:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Block-BreakList<&4>]"
lore:
- <&5>List of blocks used by block-break flag
command_entryType: block
command_verifyEntry: <def[value].as_material.is_block.not||true>
flag_type: list
flag_parent: dRegions_Flag_Block-Break
flag_takeGroup: false
flag_help: List flag used with block-break flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Chest-Access:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Chest-Access<&4>]"
lore:
- <&5>Can players open containers.
event_hook: openContainer
event_priority: 10
flag_type: state-withTarget-withGroup
flag_name: chest-access
flag_targetList: chest-access-blocks
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
region_highestOnly: true
flag_help: State flag controlling whether players will be able to open containers in this region. Defaults to deny nonmembers. Use chest-access-blocks flag to specify container blocks types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.chest-access.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:true d:10s
- queue clear
}
- if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:false d:10s
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|chest-access]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- flag <player> dRegions.cache.%world%.%value%.chest-access.%target%:none
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|chest-access-blocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.chest-access.%target%:true
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|chest-access]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|chest-access-blocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.chest-access.%target%:true
}
else {
- flag <player> dRegions.cache.%world%.__global__.chest-access.%target%:none
}
event-cleanup:
- if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.chest-access.%target%:false
- run locally msg delay:1t 'def:<c.location.material.name.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not open %1%s in this region!'
}
dRegions_Flag_Chest-Access-Blocks:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Chest-Access-Blocks<&4>]"
lore:
- <&5>List of blocks used by chest-access flag
command_entryType: container
command_verifyEntry: <el@val[chest|ender_chest|locked_chest|trapped_chest|dispenser|hopper|dropper].as_list.contains[<def[value]>].not>
flag_type: list
flag_parent: dRegions_Flag_Chest-Access
flag_takeGroup: false
flag_help: List flag used with chest-access flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks. Valid container blocks<&co> chest, ender_chest, locked_chest, trapped_chest, dispenser, hopper, and dropper.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Door-Access:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Door-Access<&4>]"
lore:
- <&5>Can players open doors.
event_hook: openDoor
event_priority: 10
flag_type: state-withTarget-withGroup
flag_name: Door-Access
flag_targetList: Door-Access-Doors
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
flag_help: State flag controlling whether players will be able to open doors in this region. Defaults to allow all. Use door-access-doors flag to specify door blocks types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.door-access.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
- queue clear
}
- if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:false d:10s
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|door-access]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%value%.door-access.%target%:none
}
}
- if %flagObj% != null {
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|door-access-doors].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.door-access.%target%:true
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
}
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|door-access]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|door-access-doors].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.door-access.%target%:true
}
else {
- if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.door-access.%target%:none
}
event-cleanup:
- if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.door-access.%target%:false
- run locally msg delay:1t 'def:<c.location.material.name.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not open %1%s in this region!'
}
dRegions_Flag_Door-Access-Doors:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Door-Access-Doors<&4>]"
lore:
- <&5>List of doors used by doors-access flag
command_entryType: door
command_verifyEntry: <el@val[trap_door|iron_trapdoor|wooden_door|iron_door_block|spruce_door|birch_door|jungle_door|dark_oak_door|acacia_door|fence_gate|spruce_fence_gate|birch_fence_gate|jungle_fence_gate|dark_oak_fence_gate|acacia_fence_gate].as_list.contains[<def[value]>].not>
flag_type: list
flag_parent: dRegions_Flag_Door-Access
flag_takeGroup: false
flag_help: List flag used with door-access flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks. Valid door blocks<&co> trap_door, iron_trapdoor, wooden_door, iron_door_block, spruce_door, birch_door, jungle_door, dark_oak_door, acacia_door, fence_gate, spruce_fence_gate, birch_fence_gate, jungle_fence_gate, dark_oak_fence_gate, and acacia_fence_gate.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Use-Switches:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Use-Switches<&4>]"
lore:
- <&5>Can players interact with switches.
event_hook: useSwitch
event_priority: 10
flag_type: state-withTarget-withGroup
flag_name: Use-Switches
flag_targetList: Use-Switches-List
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
region_highestOnly: true
flag_help: State flag controlling whether players will be able to use switches in this region. Defaults to deny nonmembers. Use use-switches-list flag to specify switch block types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.use-switches.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:true d:10s
- queue clear
}
- if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:false d:10s
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|use-switches]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- flag <player> dRegions.cache.%world%.%value%.use-switches.%target%:none
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|use-switches-list].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.use-switches.%target%:true
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|use-switches]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|use-switches-list].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.use-switches.%target%:true
}
else {
- flag <player> dRegions.cache.%world%.__global__.use-switches.%target%:none
}
event-cleanup:
- if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.use-switches.%target%:false
- run locally msg delay:1t 'def:<c.location.material.name.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not use %1%s in this region!'
}
dRegions_Flag_Use-Switches-List:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Use-Switches-List<&4>]"
lore:
- <&5>List of switches used by use-switches flag
command_entryType: switch
command_verifyEntry: <el@val[lever|wood_button|stone_button|wood_plate|stone_plate|iron_plate|gold_plate].as_list.contains[<def[value]>].not>
flag_type: list
flag_parent: dRegions_Flag_Use-Switches
flag_takeGroup: false
flag_help: List flag used with use-switches flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks. Valid switch blocks<&co> lever, wood_button, stone_button, wood_plate, stone_plate, iron_plate, and gold_plate.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Use-Utilities:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Use-Utilities<&4>]"
lore:
- <&5>Can players use utility blocks.
event_hook: useUtility
event_priority: 10
flag_type: state-withTarget-withGroup
flag_name: Use-Utilities
flag_targetList: Use-Utilities-Blocks
flag_takeGroup: true
flag_defaultValue: deny/nonmembers
flag_globalDefault: none
region_highestOnly: true
flag_help: State flag controlling whether players will be able to use utility blocks in this region. Defaults to deny nonmembers. Use use-utilities-blocks flag to specify utility blocks. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.use-utilities.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:true d:10s
- queue clear
}
- if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:false d:10s
- run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|use-utilities]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- flag <player> dRegions.cache.%world%.%value%.use-utilities.%target%:none
}
}
- if %flagObj% == null {
- define flagObj 'deny/nonmembers'
}
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|use-utilities-blocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.use-utilities.%target%:true
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|use-utilities]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|use-utilities-blocks].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.use-utilities.%target%:true
}
else {
- flag <player> dRegions.cache.%world%.__global__.use-utilities.%target%:none
}
event-cleanup:
- if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.use-utilities.%target%:false
- run locally msg delay:1t 'def:<c.location.material.name.replace[_].with[ ]>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not use %1%s in this region!'
}
dRegions_Flag_Use-Utilities-Blocks:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Use-Utilities-Blocks<&4>]"
lore:
- <&5>List of blocks used by use-utilities flag
command_entryType: utility
command_verifyEntry: <el@val[workbench|furnace|burning_furnace|anvil|cauldron|brewing_stand|enchantment_table|note_block|jukebox|beacon].as_list.contains[<def[value]>].not>
flag_type: list
flag_parent: dRegions_Flag_Use-Utilities
flag_takeGroup: false
flag_help: List flag used with use-utilities flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks. Valid utility blocks<&co> workbench, furnace, burning_furnace, anvil, brewing_stand, cauldron, enchantment_table, note_block, jukebox, and beacon.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Player-Damage:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Damage<&4>]"
lore:
- <&5>Can players take damage.
event_hook: playerDamaged
event_priority: 10
flag_type: state-withTarget-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
region_highestOnly: false
flag_help: State flag controlling whether players will take damage in this region. Defaults to allow all. Use player-damage-types flag to specify damage types. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define thisRegion '<def[orderedRegions].get[1]>'
- foreach %orderedRegions% {
- define cache '<player.flag[dRegions.cache.%world%.%value%.player-damage.%target%]||null>'
- if %cache% == none {
- define flagObj 'null'
- foreach next
}
- if %cache% != null {
- if %cache% {
- flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
- queue clear
}
- adjust <player> 'fire_time:0'
- flag <player> dRegions.rateLimit.player-damage.%target%:false d:10s
- determine cancelled
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-damage]>'
- if %flagObj% != null {
- define region '%value%'
- foreach stop
}
else {
- flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%value%.player-damage.%target%:none
}
}
- if %flagObj% != null {
- define player <player>
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|player-damage-types].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.player-damage.%target%:true
}
else {
- flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
}
event-global:
- define thisRegion '__global__'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-damage]>'
- if %flagObj% != null {
- define orderedRegions 'li@__global__'
- define player '<player>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-damage-types].replace[, ].with[|].as_list>'
- inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
- flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.player-damage.%target%:true
}
else {
- flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
- flag <player> dRegions.cache.%world%.__global__.player-damage.%target%:none
}
event-cleanup:
- flag <player> dRegions.rateLimit.player-damage.%target%:false d:10s
- flag <player> dRegions.cache.%world%.%thisRegion%.player-damage.%target%:false
- adjust <player> 'fire_time:0'
dRegions_Flag_Player-Damage-Types:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Damage-Types<&4>]"
lore:
- <&5>List of damage types used by player-damage flag
command_entryType: cause
command_verifyEntry: <el@val[BLOCK_EXPLOSION|CONTACT|CUSTOM|DROWNING|ENTITY_ATTACK|ENTITY_EXPLOSION|FALL|FALLING_BLOCK|FIRE|FIRE_TICK|LAVA|LIGHTNING|MAGIC|MELTING|POISON|PROJECTILE|STARVATION|SUFFOCATION|SUICIDE|THORNS|VOID|WITHER].as_list.contains[<def[value]>].not>
flag_type: list
flag_parent: dRegions_Flag_Player-Damage
flag_takeGroup: false
flag_help: List flag used with player-damage flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of damage types. Valid damage types<&co> block_explosion, contact, custom, drowning, entity_attack, entity_explosion, fall, falling_block, fire, fire_tick, lava, lightning, magic, melting, poison, projectile, starvation, suffocation, suicide, thorns, void, and wither.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Commands:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Commands<&4>]"
lore:
- <&5>Can players use commands.
event_hook: playerCommand
event_priority: 10
flag_type: state-withTargetString-withGroup
flag_takeGroup: true
flag_defaultValue: none
flag_globalDefault: none
region_highestOnly: false
flag_help: State flag controlling whether players can use commands in this region. Defaults to allow all. Use commands-list flag to specify commands. Takes the -g group switch.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define player <player>
- define flag 'commands'
- define flag-targetList 'commands-list'
- define delimiter ' ; '
- inject s@dRegions_Flags_Processors p:state-withTargetString-withGroup
}
event-global:
- if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
- define player <player>
- define flag 'commands'
- define flag-targetList 'commands-list'
- define delimiter ' ; '
- inject s@dRegions_Flags_Processors p:state-withTargetString-withGroup-Global
}
event-cleanup:
- run locally msg delay:1t 'def:<def[target].split[ ].parse[replace[regex:^].with[<&e>]].as_string>'
msg:
- ^if <player.has_flag[dRegions_Message_Cooldown].not> {
- flag <player> dRegions_Message_Cooldown duration:3s
- define lines '<proc[dRegions_LineWrap].context[You can not use the %1% <&c>command in this region!|45]>'
- foreach %lines% {
- run s@dRegions_Msg delay:1t 'def:<&c>%value%'
}
}
dRegions_Flag_Commands-List:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Commands-List<&4>]"
lore:
- <&5>List of commands used by commands flag
command_entryType: cause
flag_type: list
flag_parent: dRegions_Flag_Commands
flag_takeGroup: false
flag_help: List flag used with commands flag. To add to the list, use the -a switch. To remove from list use the -r switch. Add/remove one command at a time!
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_stringList
dRegions_Flag_Heal-Amount:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Heal-Amount<&4>]"
lore:
- <&5>The amount to heal or harm.
event_hook: regionEnter
event_priority: 10
flag_type: number
flag_help: Set the amount to heal or hurt a player while inside a region. Defaults to no effect. Positive number will heal players, negative numbers will damage players.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define healAmount '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-amount]>'
- if %healAmount% != null {
- define healDelay '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-delay]>'
- if %healDelay% == null {
- define healDelay '5'
}
- define healMax '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-max]>'
- if %healMax% == null {
- define healMax '20'
}
- define healMax '<tern[<def[healMax].is[MORE].than[<player.health.max>]>]:<player.health.max>||%healMax%>'
- define healMin '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-min]>'
- if %healMin% == null {
- define healMin '0'
}
- if <queue.exists[dRegions_Heal_<player.name>]> {
- queue q@dRegions_Heal_<player.name> clear
}
- run locally healTask delay:1t 'def:%world%|%region%|%healAmount%|%healDelay%|%healMax%|%healMin%' id:dRegions_Heal_<player.name>
}
event-global:
- define healAmount '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|heal-amount]>'
- if %healAmount% != null {
- define healDelay '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|heal-delay]>'
- if %healDelay% == null {
- define healDelay '5'
}
- define healMax '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|heal-max]>'
- if %healMax% == null {
- define healMax '20'
}
- define healMax '<tern[<def[healMax].is[MORE].than[<player.health.max>]>]:<player.health.max>||%healMax%>'
- define healMin '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|heal-min]>'
- if %healMin% == null {
- define healMin '0'
}
- if <queue.exists[dRegions_Heal_<player.name>]> {
- queue q@dRegions_Heal_<player.name> clear
}
- run locally healTask delay:1t 'def:%world%|__global__|%healAmount%|%healDelay%|%healMax%|%healMin%' id:dRegions_Heal_<player.name>
}
healTask:
- while <player.is_online> {
- define world '<player.world.name>'
- if %world% != %1% {
- while stop
}
- define regionPri 'li@'
- foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- if <def[regionPri].alphanumeric.reverse.parse[split[/].get[2]].get[1]> != %2% {
- while stop
}
- if <player.gamemode.id> == 1 {
- wait 1s
- while next
}
- if %4% OR_LESS 0 {
- if %3% MORE 0 {
- if <player.health> LESS %5% {
- adjust <player> 'health:%5%'
}
}
else {
- if <player.health> MORE %6% {
- animate <player> animation:hurt
- adjust <player> 'health:%6%'
}
}
- wait 1s
- while next
}
- if %3% MORE 0 {
- if <player.health> LESS %5% {
- define newHealth '<player.health.add[%3%]>'
- adjust <player> 'health:<tern[<def[newHealth].is[MORE].than[%5%]>]:%5%||%newHealth%>'
}
}
else {
- if <player.health> MORE %6% {
- animate <player> animation:hurt
- define newHealth '<player.health.add[%3%]>'
- adjust <player> 'health:<tern[<def[newHealth].is[LESS].than[%6%]>]:%6%||%newHealth%>'
}
}
- wait <def[4].as_duration>
}
dRegions_Flag_Heal-Delay:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Heal-Delay<&4>]"
lore:
- <&5>The duration between heal intervals
flag_type: number
flag_takeGroup: false
flag_help: Set the time in seconds between heal intervals. Defaults to 5 seconds.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- if <def[flagValue].is[LESS].than[0]> {
- run s@dRegions_Msg delay:1t 'def:<&c>Can not specify negative time!'
- queue clear
}
dRegions_Flag_Heal-Max:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Heal-Max<&4>]"
lore:
- <&5>Max health for heal flag.
flag_type: number
flag_takeGroup: false
flag_help: Set the max health that the heal flag will heal a player to. Defaults to 20.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- if !<def[flagValue].is[MORE].than[0]> {
- run s@dRegions_Msg delay:1t 'def:<&c>Must be a value greater than 0!'
- queue clear
}
dRegions_Flag_Heal-Min:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Heal-Min<&4>]"
lore:
- <&5>Minimum health for heal flag
flag_type: number
flag_takeGroup: false
flag_help: Set the min health that the heal flag will heal a player to. Defaults to 0.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- if <def[flagValue].is[LESS].than[0]> {
- run s@dRegions_Msg delay:1t 'def:<&c>Can not set to a negative number!'
- queue clear
}
dRegions_Flag_Feed-Amount:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Feed-Amount<&4>]"
lore:
- <&5>The amount to feed or starve.
event_hook: regionEnter
event_priority: 10
flag_type: number
flag_help: Set the amount to feed or starve a player while inside a region. Defaults to no effect. Positive numbers will feed players, negative numbers will starve players.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
event:
- define feedAmount '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-amount]>'
- if %feedAmount% != null {
- define feedDelay '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-delay]>'
- if %feedDelay% == null {
- define feedDelay '5'
}
- define feedMax '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-max]>'
- if %feedMax% == null {
- define feedMax '20'
}
- define feedMin '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-min]>'
- if %feedMin% == null {
- define feedMin '0'
}
- if <queue.exists[dRegions_Feed_<player.name>]> {
- queue q@dRegions_Feed_<player.name> clear
}
- run locally feedTask delay:1t 'def:%world%|%region%|%feedAmount%|%feedDelay%|%feedMax%|%feedMin%' id:dRegions_Feed_<player.name>
}
event-global:
- define feedAmount '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|feed-amount]>'
- if %feedAmount% != null {
- define feedDelay '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|feed-delay]>'
- if %feedDelay% == null {
- define feedDelay '5'
}
- define feedMax '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|feed-max]>'
- if %feedMax% == null {
- define feedMax '20'
}
- define feedMin '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|feed-min]>'
- if %feedMin% == null {
- define feedMin '0'
}
- if <queue.exists[dRegions_Feed_<player.name>]> {
- queue q@dRegions_Feed_<player.name> clear
}
- run locally feedTask delay:1t 'def:%world%|__global__|%feedAmount%|%feedDelay%|%feedMax%|%feedMin%' id:dRegions_Feed_<player.name>
}
feedTask:
- while <player.is_online> {
- define world '<player.world.name>'
- if %world% != %1% {
- while stop
}
- define regionPri 'li@'
- foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- define region '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]].get[1]>'
- if <def[regionPri].alphanumeric.reverse.parse[split[/].get[2]].get[1]> != %2% {
- while stop
}
- if <player.gamemode.id> == 1 {
- wait 1s
- while next
}
- if %4% OR_LESS 0 {
- if %3% MORE 0 {
- if <player.food_level> LESS %5% {
- adjust <player> 'food_level:%5%'
- adjust <player> 'saturation:<player.food_level>'
}
}
else {
- if <player.food_level> MORE %6% {
- animate <player> animation:hurt
- adjust <player> 'food_level:%6%'
- adjust <player> 'saturation:<player.food_level>'
}
}
- wait 1s
- while next
}
- if %3% MORE 0 {
- if <player.food_level> LESS %5% {
- define newFood '<player.food_level.add[%2%]>'
- adjust <player> 'food_level:<tern[<def[newFood].is[MORE].than[%5%]>]:%5%||%newFood%>'
- adjust <player> 'saturation:<player.food_level>'
}
}
else {
- if <player.food_level> MORE %6% {
- define newFood '<player.food_level.add[%3%]>'
- adjust <player> 'food_level:<tern[<def[newFood].is[LESS].than[%6%]>]:%6%||%newFood%>'
- adjust <player> 'saturation:<player.food_level>'
- animate <player> animation:hurt
}
}
- wait <def[4].as_duration>
}
dRegions_Flag_Feed-Delay:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Feed-Delay<&4>]"
lore:
- <&5>The duration between feed intervals
flag_type: number
flag_takeGroup: false
flag_help: Set the time in seconds between feed intervals. Defaults to 5 seconds.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- if <def[flagValue].is[LESS].than[0]> {
- run s@dRegions_Msg delay:1t 'def:<&c>Can not specify negative time!'
- queue clear
}
dRegions_Flag_Feed-Max:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Feed-Max<&4>]"
lore:
- <&5>Max health for feed flag.
flag_type: number
flag_takeGroup: false
flag_help: Set the max food level that the feed-amount flag will bring a player to. Defaults to 20.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- if !<def[flagValue].is[MORE].than[0]> {
- run s@dRegions_Msg delay:1t 'def:<&c>Must be a value greater than 0!'
- queue clear
}
dRegions_Flag_Feed-Min:
type: item
speed: 0
debug: false
material: i@paper
display name: "<&4>[<&6>Feed-Min<&4>]"
lore:
- <&5>Minimum food level for feed-amount flag
flag_type: number
flag_takeGroup: false
flag_help: Set the min food level that the feed-amount flag will bring a player to. Defaults to 0.
script:
- narrate "A handy container for region flags."
- narrate "We<&sq>ll have subscripts for various tasks."
button_click:
- narrate "This will be useful when it comes time to make the GUI for region management."
command_handler:
- if <def[flagValue].is[LESS].than[0]> {
- run s@dRegions_Msg delay:1t 'def:<&c>Can not set to a negative number!'
- queue clear
}
################################################################################
dRegions_Flags_Processors:
type: task
speed: 0
debug: false
#---------------------------------------
# Region flag pre-processors
#
state-withGroup:
# Requires each flag to build the flag object.
# Allows for iterating over %orderedRegions% from within the flag
# Membership is checked against the highest priority region while flag value
# can be set in any region in %orderedRegions%
- if <def[flagObj].split[/].get[1]> == allow {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
else {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
state-withTarget:
- if %flagVal% == allow {
- if %targetList% != li@null && %targetList% != li@all && %targetList% !contains %target% {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
else {
- if %targetList% == li@null || %targetList% == li@all || %targetList% contains %target% {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
state-withTarget-withGroup:
- if <def[flagObj].split[/].get[1]> == allow {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%thisRegion%|%world%|%player%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
- if %targetList% != li@null && %targetList% != li@all && %targetList% !contains %target% {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
else {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%thisRegion%|%world%|%player%]> {
- if %targetList% == li@null || %targetList% == li@all || %targetList% contains %target% {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
}
state-withTargetString-withGroup:
- if <def[FlagScript].yaml_key[region_highestOnly]||false> {
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag%]>'
}
else {
- foreach %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
- define region '%value%'
- if %flagObj% != null {
- foreach stop
}
}
}
- if %flagObj% == null {
- define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
}
- if %flagObj% != none {
- if <def[flagObj].split[/].get[1]> == allow {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[<def[delimiter]||, >].with[|].as_list>'
- if ( %targetList% != li@null ) && ( %targetList% != li@all ) {
- foreach %targetList% {
- if <def[target].starts_with[%value%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
}
}
else {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[<def[delimiter]||, >].with[|].as_list>'
- if ( %targetList% == li@null ) || ( %targetList% == li@all ) {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
- foreach %targetList% {
- if <def[target].starts_with[%value%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
}
}
}
##############################
# Abstract methods
#
# state-withTarget:
# - if <def[FlagScript].yaml_key[region_highestOnly]||false> {
# - define orderedRegions '<def[orderedRegions].get[1].as_list>'
# }
# - foreach %orderedRegions% {
# - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
# - if %flagVal% == null {
# - foreach next
# }
# - define region '%value%'
# - foreach stop
# }
# - inject locally state-process-WithTargetNoGroup_%flagVal%
# - queue clear
# state-withGroup:
# - if <def[FlagScript].yaml_key[region_highestOnly]||false> {
# - define orderedRegions '<def[orderedRegions].get[1].as_list>'
# }
# - foreach %orderedRegions% {
# - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
# - if %flagObj% == null {
# - foreach next
# }
# - define region '%value%'
# - foreach stop
# }
# - inject locally state-process-WithGroup_<def[flagObj].split[/].get[1]>
# - queue clear
# state-withTarget-withGroup:
# - if <def[FlagScript].yaml_key[region_highestOnly]||false> {
# - define orderedRegions '<def[orderedRegions].get[1].as_list>'
# }
# - foreach %orderedRegions% {
# - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
# - if %flagObj% == null {
# - foreach next
# }
# - define region '%value%'
# - foreach stop
# }
# - inject locally state-process-WithTargetWithGroup_<def[flagObj].split[/].get[1]>
# - queue clear
#---------------------------------------
# Global flag pre-processors
#
boolean-Global:
- define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]||null>'
- if %flagVal% == null {
- define flagVal '<def[FlagScript].yaml_key[flag_globalDefault]||true>'
}
- if !%flagVal% {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
state-withGroup-Global:
- if <def[flagObj].split[/].get[1]> == allow {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
else {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
state-withTargetString-withGroup-Global:
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>'
- if %flagObj% == null {
- define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
}
- if %flagObj% != none {
- if <def[flagObj].split[/].get[1]> == allow {
- if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[<def[delimiter]||, >].with[|].as_list>'
- if ( %targetList% != li@null ) && ( %targetList% != li@all ) {
- foreach %targetList% {
- if <def[target].starts_with[%value%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
}
}
else {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[<def[delimiter]||, >].with[|].as_list>'
- if ( %targetList% == li@null ) || ( %targetList% == li@all ) {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
- foreach %targetList% {
- if <def[target].starts_with[%value%]> {
- inject %FlagScript% p:event-cleanup
- determine cancelled
}
}
}
}
}
##############################
# Abstract methods
#
# state-withGroup-Global:
# - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>'
# - inject locally state-process-Global-WithGroup_<def[flagObj].split[/].get[1]>
# - queue clear
# state-withTarget-Global:
# - inject locally state-process-Global-WithTargetNoGroup_<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>
# - queue clear
# state-withTarget-withGroup-Global:
# - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>'
# - inject locally state-process-Global-WithTargetWithGroup_<def[flagObj].split[/].get[1]>
# - queue clear
#-------------------
# Global WithGroup Flag Processors
#
# state-process-Global-WithGroup_null:
# - define flagObj '<def[FlagScript].yaml_key[flag_globalDefault]||none>'
# - inject locally state-process-Global-WithGroup_<def[flagObj].split[/].get[1]>
# state-process-Global-WithGroup_none:
# - foreach next
# - queue clear
# state-process-Global-WithGroup_allow:
# - define group '<def[flagObj].split[/].get[2]||all>'
# - inject locally state-process-Global-WithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|__global__|%world%|%player%].not>
# state-process-Global-WithGroup_deny:
# - define group '<def[flagObj].split[/].get[2]||all>'
# - inject locally state-process-Global-WithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|__global__|%world%|%player%]>
# state-process-Global-WithGroup_deny-true:
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
#-------------------
# Global WithTargetWithGroup Flag Processors
#
# state-process-Global-WithTargetWithGroup_null:
# - define flagObj '<def[FlagScript].yaml_key[flag_globalDefault]||none>'
# - inject locally state-process-Global-WithTargetWithGroup_<def[flagObj].split[/].get[1]>
# state-process-Global-WithTargetWithGroup_none:
# - foreach next
# - queue clear
# state-process-Global-WithTargetWithGroup_allow:
# - define group '<def[flagObj].split[/].get[2]||all>'
# - inject locally state-process-Global-WithTargetWithGroup_allow-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|__global__|%world%|%player%]>
# state-process-Global-WithTargetWithGroup_allow-true:
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
# - if %targetList% == li@null {
# - queue clear
# }
# - if %targetList% != li@all {
# - if %targetList% !contains %target% {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# }
# state-process-Global-WithTargetWithGroup_allow-false:
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# state-process-Global-WithTargetWithGroup_deny:
# - define group '<def[flagObj].split[/].get[2]||all>'
# - inject locally state-process-Global-WithTargetWithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|__global__|%world%|%player%]>
# state-process-Global-WithTargetWithGroup_deny-true:
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
# - if %targetList% == li@null {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# - if %targetList% == li@all {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# - if %targetList% contains %target% {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
#-------------------
# Global WithTargetNoGroup Flag Processors
#
# state-process-Global-WithTargetNoGroup_null:
# - inject locally state-process-Global-WithTargetNoGroup_<def[FlagScript].yaml_key[flag_globalDefalut]||none>
# state-process-Global-WithTargetNoGroup_none:
# - foreach next
# - queue clear
# state-process-Global-WithTargetNoGroup_allow:
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
# - if %targetList% == 'li@null' {
# - queue clear
# }
# - if %targetList% != li@all {
# - if %targetList% !contains %target% {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# }
# state-process-Global-WithTargetNoGroup_deny:
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
# - if %targetList% == li@null {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# - if %targetList% == li@all {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# - if %targetList% contains %target% {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
#-------------------
# Region WithGroup Flag Processors
#
# state-process-WithGroup_null:
# - define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
# - inject locally state-process-WithGroup_<def[flagObj].split[/].get[1]>
# state-process-WithGroup_none:
# - foreach next
# - queue clear
# state-process-WithGroup_allow:
# - define group '<def[flagObj].split[/].get[2]||all>'
# - inject locally state-process-WithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|<def[orderedRegions].get[1]>|%world%|%player%].not>
# state-process-WithGroup_deny:
# - define group '<def[flagObj].split[/].get[2]||all>'
# - inject locally state-process-WithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|<def[orderedRegions].get[1]>|%world%|%player%]>
# state-process-WithGroup_deny-true:
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
#-------------------
# Region WithTargetWithGroup Flag Processors
#
# state-process-WithTargetWithGroup_null:
# - define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
# - inject locally state-process-WithTargetWithGroup_<def[flagObj].split[/].get[1]>
# state-process-WithTargetWithGroup_none:
# - foreach next
# - queue clear
# state-process-WithTargetWithGroup_allow:
# - define group '<def[flagObj].split[/].get[2]||all>'
# - inject locally state-process-WithTargetWithGroup_allow-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|<def[orderedRegions].get[1]>|%world%|%player%]>
# state-process-WithTargetWithGroup_allow-true:
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
# - if %targetList% == li@null {
# - queue clear
# }
# - if %targetList% != li@all {
# - if %targetList% !contains %target% {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# }
# state-process-WithTargetWithGroup_allow-false:
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# state-process-WithTargetWithGroup_deny:
# - define group '<def[flagObj].split[/].get[2]||all>'
# - inject locally state-process-WithTargetWithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|<def[orderedRegions].get[1]>|%world%|%player%]>
# state-process-WithTargetWithGroup_deny-true:
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
# - if %targetList% == li@null {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# - if %targetList% == li@all {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# - if %targetList% contains %target% {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
#-------------------
# Region WithTargetNoGroup Flag Processors
#
# state-process-WithTargetNoGroup_null:
# - inject locally state-process-WithTargetNoGroup_<def[FlagScript].yaml_key[flag_defaultValue]||none>
# state-process-WithTargetNoGroup_none:
# - foreach next
# - queue clear
# state-process-WithTargetNoGroup_allow:
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
# - if %targetList% == 'li@null' {
# - queue clear
# }
# - if %targetList% != li@all {
# - if %targetList% !contains %target% {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# }
# state-process-WithTargetNoGroup_deny:
# - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
# - if %targetList% == li@null {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# - if %targetList% == li@all {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
# - if %targetList% contains %target% {
# - inject %FlagScript% p:event-cleanup
# - determine cancelled
# }
#-------------------------------------------------------------------------------
dRegions_Flags_CommandProcessors:
type: task
speed: 0
debug: false
command_verifiedList:
- if <def[flagValue].is[==].to[null]||false> {
- yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
- queue clear
}
else {
- define entries '<def[flagValue].split[ ].get[2].to[<def[flagValue].split[ ].size>].parse[to_lowercase].deduplicate||li@>'
- if <def[entries].get[1].is[==].to[all]> {
- if '<def[flagValue].split[ ].get[1].is[==].to[-a]||false>' {
- yaml set 'regions.%region%.flags.%flag%:all' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg delay:1t 'def:<&f><&o>%region%<&7><&o> set %flag% flag to <&f><&o>%flagValue%'
- queue clear
}
- if '<def[flagValue].split[ ].get[1].is[==].to[-r]||false>' {
- yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
- queue clear
}
}
- foreach %entries% {
- if <parse:<s@dRegions_Flag_%Flag%.yaml_key[command_verifyEntry]||false>> {
- define entries '<def[entries].exclude[%value%]||li@>'
- run s@dRegions_Msg 'def:<&c><&o>%value% is not a valid <s@dRegions_Flag_%Flag%.yaml_key[command_entryType]>!'
}
}
- if <def[entries].is_empty||true> {
- run s@dRegions_Msg 'def:<&c><&o>No valid <s@dRegions_Flag_%Flag%.yaml_key[command_entryType]>s specified!'
- define lines '<proc[dRegions_LineWrap].context[<s@dRegions_Flag_%Flag%.yaml_key[flag_help]||<&c>%flag% flag requires a %type% value!>|45]>'
- foreach <def[lines]> {
- run s@dRegions_Msg delay:1t 'def:<&c><def[value]>'
}
- queue clear
}
- define currentEntries '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%].replace[, ].with[|].as_list||li@>'
- if '<def[flagValue].split[ ].get[1].is[==].to[-a]||false>' {
- define flagValue '<def[currentEntries].include[<def[entries].replace[li@]>].deduplicate||li@>'
}
- if '<def[flagValue].split[ ].get[1].is[==].to[-r]||false>' {
- define flagValue '<def[currentEntries].exclude[<def[entries].replace[li@]>].deduplicate||li@>'
}
- if <def[flagValue].is_empty||true> {
- yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
- queue clear
}
- define flagValue '<def[flagValue].comma_separated>'
}
command_stringList:
- if <def[flagValue].is[==].to[null]||false> {
- yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
- queue clear
}
- define action '<def[flagValue].split[ ].get[1]>'
- define string '<def[flagValue].after[<def[action]>]>'
- if '<def[string].is[==].to[all]>' {
- if <def[action].is[==].to[-a]||false> {
- yaml set 'regions.%region%.flags.%flag%:all' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg delay:1t 'def:<&f><&o>%region%<&7><&o> set %flag% flag to <&f><&o>%flagValue%'
- queue clear
}
- if <def[action].is[==].to[-r]||false> {
- yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
- queue clear
}
}
- if <def[string].length.is[==].to[0]||true> {
- run s@dRegions_Msg 'def:<&c><&o>No valid <s@dRegions_Flag_%Flag%.yaml_key[command_entryType]>s specified!'
- define lines '<proc[dRegions_LineWrap].context[<s@dRegions_Flag_%Flag%.yaml_key[flag_help]||<&c>%flag% flag requires a %type% value!>|45]>'
- foreach <def[lines]> {
- run s@dRegions_Msg delay:1t 'def:<&c><def[value]>'
}
- queue clear
}
- define currentEntries '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%].replace[ ; ].with[|].as_list||li@>'
- if '<def[action].is[==].to[-a]||false>' {
- define flagValue '<def[currentEntries].include[<def[string]>].deduplicate||li@>'
}
- if '<def[action].is[==].to[-r]||false>' {
- define flagValue '<def[currentEntries].exclude[<def[string]>].deduplicate||li@>'
}
- if <def[flagValue].is_empty||true> {
- yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
- queue clear
}
- define flagValue '<def[flagValue].replace[|].with[ ; ].replace[li@]>'
#