################################################################################
#
# d R e g i o n s
#
#
# Authors: |Anthony|
-# Version: 0.32
+# Version: 0.33
# dScript Version: 0.9.8-DEV_b579
#
#
# Dependencies:
#
# - dWorldEditor
# - Integrates with region selection wand
# - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/dWE/dWorldEditor.yml
#
# - MessageConstructorLibrary
# - Library for messaging system.
# - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/MessageConstructors.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 is bundled in the repo releases.
# - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/dRegions/flags.yml
#
# - Commands
# - All the commands for dRegions. It is bundled in the repo releases.
# - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/dRegions/commands.yml
+#
+ Has my work helped you in some way? Show your support by clicking the
+# Like button.
+# Feeling generous? Get me a coffee :D
+# https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=NPXKHCNMTGSUG
#
+#
#_______________________________________________________________________________
#
#--- 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.
#
# Command Permission Description
#
# /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!
#
# Set region priority
# - /drg setpriority myRegion 10
#
# Set any region flags you need
# - /drg flag myRegion greeting Hello <player.name>!
#
#--- TODO
#
# - Make sure players can't exit a vehicle if they do not have permission to
# get back into it.
# - Add vehicle-enter and vehicle-exit flags and respective list flags.
# - Add vehicle-placelist flag.
# - Make all minecarts work with entity-interactlist flag.
# - Make the player-damage flag cover the hurt command
# - Fix eating in regions with the hunger flag set
#
#
#
################################################################################
#
# dRegions Version
#
# Handles dRegions Versioning Checks
#
dRegions_Version:
type: version
author: Anthony
name: dRegions
- version: 0.32
+ version: 0.33
description: Denizen Region Management and Protection
id: 23
#
# END dRegions Version
#--------------------------------------
#
dRegions:
type: world
debug: false
events:
on server start:
- inject locally start
on shutdown:
- define globalCache '<yaml[dRegions_global_config].read[config.clear_cache_on_restart]>'
- foreach <server.list_worlds.parse[name.to_lowercase]> {
- if %globalCache% || '<yaml[dRegions_%value%_config].read[config.clear_cache_on_restart]>' {
- if <server.has_file[dRegions/worlds/%value%/cache.yml]> {
- announce to_console "<&b>dRegions<&co><&3> Removing %value% cache.yml"
- adjust server 'delete_file:dRegions/worlds/%value%/cache.yml'
}
}
else {
- yaml 'savefile:dRegions/worlds/%value%/cache.yml' 'id:dRegions_%value%_cache'
}
}
on world initializes:
+ - if <context.world.name.starts_with[instancing/instances]> {
+ - queue clear
+ }
- run locally loadYaml instantly
on script reload:
- run locally start instantly
on player changes world:
# - 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]||null> == cancelled {
# - determine cancelled
# }
- flag <player> dRegions.cache:!
- flag <player> dRegions.rateLimit:!
on player joins:
- flag <player> dRegions.cache:!
- flag <player> dRegions.rateLimit:!
on player respawns:
- if <player.has_flag[dRegions.Respawn]> {
- determine passively '<player.flag[dRegions.Respawn].as_location||<player.location>>'
- adjust <player> 'health:<player.health.max>'
- wait 10t
- flag <player> 'dRegions.Respawn:!'
}
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 portal created:
- define world '<c.world.name.to_lowercase>'
- define readPath 'portal.create'
- inject s@dRegions p:event_PreProc_Config-NoTarget
start:
- inject locally loadYaml
- foreach '<server.list_flags[dRegions]>' {
- flag server '%value%:!'
}
- define flags '<server.list_scripts.filter[starts_with[s@dRegions_Flag_]].parse[name.after[dRegions_Flag_].to_lowercase].alphanumeric||li@>'
- flag server 'dRegions.Flags:|:%flags%'
- if <yaml.list.contains[dRegions_eventmap]> {
- yaml unload 'id:dRegions_eventmap'
}
- yaml create 'id:dRegions_eventmap'
- foreach '%flags%' {
- define flag '%value%'
- foreach <s@dRegions_Flag_%flag%.yaml_key[event_hooks].as_list||li@none> {
- yaml set '%value%:->:<s@dRegions_Flag_%flag%.yaml_key[event_priority]||0>/%flag%' 'id:dRegions_eventmap'
}
}
- yaml set 'none:!' 'id:dRegions_eventmap'
- foreach '<yaml[dRegions_eventmap].list_keys[]>' {
- define e '<yaml[dRegions_eventmap].read[%value%].as_list>'
- yaml set '%value%:!' 'id:dRegions_eventmap'
- yaml set '%value%:|:<def[e].alphanumeric.parse[after[/]]>' 'id:dRegions_eventmap'
}
- if <queue.exists[dRegions_saveCache]> {
- queue q@dRegions_saveCache stop
}
- run locally saveCache delay:5s id:dRegions_saveCache
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 version '<s@dRegions_Configurations.yaml_key[config.version]>'
- define world 'global'
- define file 'config'
- define hasFile '<server.has_file[dRegions/config.yml]>'
- if %hasFile% {
- yaml 'load:dRegions/config.yml' 'id:dRegions_global_config'
- define isUpdate '<yaml[dRegions_global_config].read[config.version].is[!=].to[%version%]||false>'
}
else {
- define isUpdate 'false'
}
- if !<server.has_file[dRegions/config.yml]> || %isUpdate% {
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally createConfigFile instantly
- flag <player> ConfigFileGeneratorNotify:!
- run s@msgPrefixed player:<player> 'def:dRegions|<&7><&o><t[%isUpdate%]:Updated||Created> <&f><&o>%world%<&7><&o> config file!'
}
else {
- inject locally createConfigFile
}
- announce "<&b>dRegions<&co> <&7><&o><t[%isUpdate%]:Updated||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'
- foreach <server.list_worlds.parse[name.to_lowercase]> {
- define world '<def[value]>'
- foreach 'li@config|regions|inventories|cache' {
- define this '%value%'
- define file 'worlds/%world%/%this%'
- define hasFile '<server.has_file[dRegions/worlds/%world%/%this%.yml]>'
- if %hasFile% {
- yaml 'load:dRegions/worlds/%world%/%this%.yml' 'id:dRegions_%world%_%this%'
- define isUpdate '<yaml[dRegions_%world%_%this%].read[%this%.version].is[!=].to[%version%]||false>'
}
else {
- define isUpdate 'false'
}
- if !%hasFile% || %isUpdate% {
- if <player.is[!=].to[null]||false> {
- flag <player> ConfigFileGeneratorNotify:true
- inject locally create%this%File
- flag <player> ConfigFileGeneratorNotify:!
- run s@msgPrefixed player:<player> 'def:dRegions|<&7><&o><t[%isUpdate%]:Updated||Created> <&f><&o>%world%<&7><&o> %this% file!'
}
else {
- inject locally create%this%File
}
- announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> %this% file!" to_console
}
- if <yaml.list.contains[dRegions_%world%_%this%]> {
- yaml unload 'id:dRegions_%world%_%this%'
}
- yaml 'load:dRegions/worlds/%world%/%this%.yml' 'id:dRegions_%world%_%this%'
}
}
- 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@msgPrefixed player:<player> 'def:dRegions|<&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]>'
- foreach 'li@config|regions|inventories|cache' {
- if <yaml.list.contains[dRegions_%world%_%value%]> {
- yaml unload 'id:dRegions_%world%_%value%'
}
- yaml 'load:dRegions/worlds/%world%/%value%.yml' 'id:dRegions_%world%_%value%'
}
}
- announce "<&b>dRegions<&co><&a> System config files reloaded!" to_console
- run s@msgPrefixed player:<player> 'def:dRegions|<&7><&o>System config files reloaded!'
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'
- run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|<def[isUpdate]||false> instantly
- yaml unload 'id:%readID%'
- yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
createRegionsFile:
- 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%'
+ - define writePath 'regions.<def[region]||__global__>'
- run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
- yaml unload 'id:%readID%'
- yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
createInventoriesFile:
- 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%'
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%'
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|<def[isReset].exists||false> instantly
- yaml unload 'id:%readID%'
- yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
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]>'
- define flag '<s@dRegions_Flag_%flag%.yaml_key[flag_parent].after_last[_]>'
}
- ^define children '<yaml[dRegions_%world%_regions].read[regions.%region%.children]||li@>'
- ^foreach '<def[children].include[%region%]>':
- yaml set 'cache.%type%.%value%.%flag%:!' 'id:dRegions_%world%_cache'
- ^yaml 'savefile:dRegions/worlds/%world%/cache.yml' 'id:dRegions_%world%_cache'
saveCache:
- while 'true':
- wait 5m
- foreach '<server.list_worlds.parse[name.to_lowercase]>':
- if !<yaml.list.contains[dRegions_%value%_cache]> {
- yaml 'load:dRegions/worlds/%value%/cache.yml' 'id:dRegions_%value%_cache'
}
- yaml 'savefile:dRegions/worlds/%value%/cache.yml' 'id:dRegions_%value%_cache'
# Event Preprocessors
#
# 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.
#
event_PreProc_Config:
- define targetList '<yaml[dRegions_%world%_config].read[config.%readPath%-list]||li@>'
# - if '<t[<yaml[dRegions_%world%_config].read[config.%readPath%]||true>]:<def[targetList].is_empty.not.and[<def[targetList].contains[%target%].not>]>||<def[targetList].is_empty.or[<def[targetList].contains[%target%]>]>>' {
# - determine cancelled
# }
- if '<yaml[dRegions_%world%_config].read[config.%readPath%]||true>' {
- if '<def[targetList].is_empty.not>' && '%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 '<t[<yaml[dRegions_global_config].read[config.%readPath%]||true>]:<def[targetList].is_empty.not.and[<def[targetList].contains[%target%].not>]>||<def[targetList].is_empty.or[<def[targetList].contains[%target%]>]>>' {
# - determine cancelled
# }
- if '<yaml[dRegions_global_config].read[config.%readPath%]||true>' {
- if '<def[targetList].is_empty.not>' && '%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%].not||false> || <yaml[dRegions_global_config].read[config.%readPath%].not||false> {
- determine cancelled
}
#
#
#
#
################################################################################
#
# Player/Entity Events
#
dRegions_Events_Player_Interact_Entity:
type: world
debug: false
eventHooks: player_interact_entity
events:
on player right clicks entity:
- if <c.entity.is_player> || <c.entity.is_npc> || <c.entity.entity_type> == item_frame {
- queue clear
}
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.entity>'
- define target '<c.entity.entity_type>'
- define eLoc '<def[object].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_interact_entity]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Interact_NPC:
type: world
debug: false
eventHooks: player_interact_npc
events:
on player right clicks npc:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.entity>'
- define target '<c.entity.entity_type>'
- define eLoc '<def[object].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_interact_npc]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Enters_Region:
type: world
debug: false
eventHooks: player_enters_region
events:
on player enters notable cuboid:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- define noCancel ''
}
- define player '<player>'
# Should we fire an event when the player exits the global region?
- if <c.from.cuboids.is_empty> {
- event 'player exits notable cuboid' 'player:%player%' 'context:cuboids|<c.from.cuboids.escaped>|from|<c.from>|to|<c.to>' save:exit
- if <entry[exit].determinations.get[1]||null> == cancelled {
- determine cancelled
}
}
- define eLoc '<c.to>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
# Ignore crossing into lower priority region and non-dRegion cuboids
- define oldRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<c.from.cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define oldRegions '%oldRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- if '<def[orderedRegions].get[1]>' == '<def[oldRegions].alphanumeric.reverse.parse[after[/]].get[1]>' {
- queue clear
}
- foreach '<yaml[dRegions_eventmap].read[player_enters_region]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
- event 'player entered dregion' 'player:%player%' 'context:orderedregions|<def[orderedRegions].separated_by[/]>|to|<c.to>|from|<c.from>'
dRegions_Events_Player_Entered_dRegion:
type: world
debug: false
eventHooks: player_entered_dregion
events:
on player entered dregion:
- define player '<player>'
- define eLoc '<c.to>'
- define world '<def[eLoc].world.name>'
- define orderedRegions '<c.orderedregions.split_by[/]>'
- define noCancel ''
- define isEnter 'true'
- foreach '<yaml[dRegions_eventmap].read[player_entered_dregion]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Exits_Region:
type: world
debug: false
eventHooks: player_exits_region
events:
on player exits notable cuboid:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- define noCancel ''
}
- define player '<player>'
- define eLoc '<c.from>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
# Ignore crossing into lower priority region and non-dRegion cuboids
- define newRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<c.to.cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define newRegions '%newRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- if '<def[orderedRegions].get[1]>' == '<def[newRegions].alphanumeric.reverse.parse[after[/]].get[1]>' {
- queue clear
}
- foreach '<yaml[dRegions_eventmap].read[player_exits_region]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
# Should we fire an event when the player enters the global region?
- if <c.to.cuboids.is_empty> {
- event 'player enters notable cuboid' 'player:%player%' 'context:cuboids|<c.to.cuboids.escaped>|from|<c.from>|to|<c.to>' save:enter
- if <entry[enter].determinations.get[1]||null> == cancelled {
- determine cancelled
}
}
# Should exiting a region trigger entering another one. This can happen when regions overlap
# - 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].equal_case_sensitive[cancelled]||false> {
# - determine cancelled
# }
- event 'player exited dregion' 'player:%player%' 'context:orderedregions|<def[orderedRegions].separated_by[/]>|to|<c.to>|from|<c.from>'
dRegions_Events_Player_Exited_dRegion:
type: world
debug: false
eventHooks: player_exited_dregion
events:
on player exited dregion:
- define player '<player>'
- define eLoc '<c.from>'
- define world '<def[eLoc].world.name>'
- define orderedRegions '<c.orderedregions.split_by[/]>'
- define noCancel ''
- define isEnter 'false'
- foreach '<yaml[dRegions_eventmap].read[player_exited_dregion]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Place_Block:
type: world
debug: false
eventHooks: player_place_block
events:
on player places block:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define target '<c.material.bukkit_enum>'
- define eLoc '<context.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_place_block]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Break_Block:
type: world
debug: false
eventHooks: player_break_block
events:
on player breaks block:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define target '<c.material.bukkit_enum>'
- define eLoc '<context.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_break_block]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Right_Click:
type: world
debug: false
# eventHooks: These are mapped in s@dRegions_Map_Interactions
events:
on player right clicks:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define target '<c.location.material.bukkit_enum||air>'
- define item '<c.item.material.bukkit_enum||air>'
- define eventObj '<s@dRegions_Map_Interactions.yaml_key[block_withItem.%target%]||li@>'
# - define event '<t[<def[eventObj].after[/].as_list.contains[%item%]||false>]:<def[eventObj].before[/]>||<s@dRegions_Map_Interactions.yaml_key[block.%target%]||null>>'
- if '<def[eventObj].after[/].as_list>' contains '%item%' {
- define event '<def[eventObj].before[/]>'
}
else {
- define event '<s@dRegions_Map_Interactions.yaml_key[block.%target%]||null>'
}
- if '%event%' == 'null' {
- queue clear
}
- define player '<player>'
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[%event%]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Damaged:
type: world
debug: false
eventHooks: player_damaged
events:
on player damaged:
- if ( <player.permission[dregions.invincible]||false> || <player.permission[dregions.invincible.<c.cause>]||false> ) && !<player.is_op> {
- adjust <player> 'fire_time:0'
- determine cancelled
}
- define player '<c.entity>'
- define target '<c.cause>'
- define eLoc '<def[player].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_damaged]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Chat:
type: world
debug: false
eventHooks: player_chats
events:
on player chats:
- if <player.permission[dregions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define eLoc '<def[player].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_chats]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Break_Vehicle:
type: world
debug: false
eventHooks: player_break_vehicle
events:
on player destroys vehicle:
- if <player.permission[dregions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.vehicle>'
- define eLoc '<def[object].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_break_vehicle]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Place_Boat:
type: world
debug: false
eventHooks: player_place_vehicle
events:
on player right clicks block with boat:
- if <player.permission[dregions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.vehicle>'
- define eLoc '<def[object].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_place_vehicle]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Stands_On:
type: world
debug: false
eventHooks: player_interact_switches
events:
on player stands on:
- if <player.permission[dregions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define target '<c.location.material.bukkit_enum>'
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_interact_switches]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Throws_Potion:
type: world
debug: false
eventHooks: player_throw_potion
events:
on player right clicks with potion:
- if !<c.item.potion_effect.is_splash||false> || <player.permission[dregions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_throw_potion]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Drinks_Potion:
type: world
debug: false
eventHooks: player_throw_potion
events:
on player consumes potion:
- if <player.permission[dregions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define eLoc '<def[player].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_drink_potion]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Place_Armorstand:
type: world
debug: false
eventHooks: player_place_armorstand
events:
on player right clicks block with armor_stand:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define target '<c.item.material.bukkit_enum>'
- define eLoc '<context.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_place_armorstand]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Use_Monsteregg:
type: world
debug: false
eventHooks: player_use_spawnegg
events:
on player right clicks block with monster_egg:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define target '<c.item.spawn_egg_entity>'
- define eLoc '<context.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_use_spawnegg]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Throw_Egg:
type: world
debug: false
eventHooks: player_throw_hatchingegg|player_throw_egg
events:
on player throws egg:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.egg>'
- define eLoc '<def[object].location>'
- define world '<def[eLoc].world.name>'
- if <c.is_hatching> {
- define type 'hatchingegg'
}
else {
- define type 'egg'
}
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
# - foreach '<yaml[dRegions_eventmap].read[player_throw_<t[<context.is_hatching>]:hatchingegg||egg>]||li@>':
- foreach '<yaml[dRegions_eventmap].read[player_throw_%type%]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Enters_Bed:
type: world
debug: false
eventHooks: player_enters_bed
events:
on player enters bed:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define eLoc '<context.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_enters_bed]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Empties_Bucket:
type: world
debug: false
eventHooks: player_empty_bucket|build
events:
on player empties bucket:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define eLoc '<context.relative>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_empty_bucket]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Fills_Bucket:
type: world
debug: false
eventHooks: player_fill_bucket|build
events:
on player fills bucket:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_fill_bucket]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Drops_Item:
type: world
debug: false
eventHooks: player_drops_item
events:
on player drops item:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.entity>'
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_drops_item]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Pickup_Item:
type: world
debug: false
eventHooks: player_pickup_item
events:
on player picks up item:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.entity>'
- define eLoc '<def[player].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_pickup_item]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Place_Hanging:
type: world
debug: false
eventHooks: player_place_hanging
events:
on player places hanging:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.hanging>'
- define eLoc '<c.hanging.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_place_hanging]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Break_Hanging:
type: world
debug: false
eventHooks: player_break_hanging
events:
on player breaks hanging:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.entity>'
- define object '<c.hanging>'
- define eLoc '<c.hanging.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_break_hanging]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Interact_Armorstand:
type: world
debug: false
eventHooks: player_interact_armorstand
events:
on player right clicks at armor_stand:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.entity>'
- - define eLoc '<c.location>'
+ - define eLoc '<c.entity.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_interact_armorstand]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Interact_Itemframe:
type: world
debug: false
eventHooks: player_interact_itemframe
events:
on player right clicks item_frame:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define object '<c.entity>'
- define eLoc '<c.entity.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_interact_itemframe]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Extinguish_BlockFire:
type: world
debug: false
eventHooks: player_extinguish_blockfire
events:
on player left clicks block:
- if <c.relative.material.name> != fire {
- queue clear
}
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define eLoc '<c.relative>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_extinguish_blockfire]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Use_Bonemeal:
type: world
debug: false
eventHooks: player_use_bonemeal
events:
on player clicks block with bone_meal:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
- define player '<player>'
- define eLoc '<c.relative>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_use_bonemeal]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Changes_Foodlevel:
type: world
debug: false
eventHooks: player_change_foodlevel
events:
on player changes food level:
- if <c.food> >= <player.food_level> queue clear
- define player '<player>'
- define eLoc '<def[player].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_change_foodlevel]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Player_Teleports:
type: world
debug: false
eventHooks: player_teleports|player_use_enderpearl
events:
on player teleports:
- if <player.permission[dRegions.admin]||false> || <player.is_op> {
- queue clear
}
# This is here to catch teleports between global regions as there's no other event for it. Maybe it should be in its own container idk.
- if '<c.origin.world>' != '<c.destination.world>' {
- if <c.origin.cuboids.is_empty> && <c.destination.cuboids.is_empty> {
- event 'player enters notable cuboid' 'context:cuboids|<c.origin.cuboids.escaped>|from|<c.origin>|to|<c.destination>' save:enter
- if <entry[enter].determinations.get[1]||null> == cancelled {
- determine cancelled
}
}
}
- if <c.cause> != ender_pearl queue clear
- define player '<player>'
- define eLoc '<def[player].location>'
- define world '<def[eLoc].world.name>'
- define cuboids '<c.origin.cuboids.include[<c.destination.cuboids>].deduplicate>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[cuboids].filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[player_use_enderpearl]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Entity_Spawn:
type: world
debug: false
eventHooks: entity_spawn
events:
on entity spawns:
- define object '<c.entity>'
- define target '<c.entity.entity_type>'
- define eLoc '<c.entity.location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[entity_spawn]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Entity_Damage_Entity:
type: world
debug: false
eventHooks: player_damage_player|player_damage_entity|player_damage_npc|player_damage_armorstand|player_damage_itemframe|entity_damage_entity|entity_damage_player|entity_damage_npc|entity_damage_armorstand|entity_damage_itemframe|npc_damage_npc|npc_damage_player|npc_damage_entity|npc_damage_itemframe|npc_damage_armorstand
events:
on entity damages entity:
- if !<c.entity.is_spawned> || !<c.damager.is_spawned> {
- queue clear
}
# - define atype '<t[<c.damager.is_npc>]:npc||<c.damager.prefix>>'
- if <c.damager.is_npc> {
- define atype 'npc'
}
else {
- define atype '<c.damager.prefix>'
}
# - define dtype '<t[<c.entity.is_npc>]:npc||<t[<li@armor_stand|item_frame.contains[<c.entity.entity_type>]>]:<c.entity.entity_type.replace[_]>||<c.entity.prefix>>>'
- if <c.entity.is_npc> {
- define dtype 'npc'
}
else if <c.entity.entity_type> == armor_stand {
- define dtype 'armorstand'
}
else if <c.entity.entity_type> == item_frame {
- define dtype 'itemframe'
}
else {
- define dtype '<c.entity.prefix>'
}
- define attacker '<c.damager>'
- define defender '<c.entity>'
- define world '<c.damager.world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[attacker].location.cuboids.include[<def[defender].location.cuboids>].deduplicate.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[%atype%_damage_%dtype%]||li@>':
- define flag '%value%'
- define object '<def[<s@dRegions_Flag_%flag%.yaml_key[event_target]>]>'
- define player '<def[<s@dRegions_Flag_%flag%.yaml_key[event_player]||object>]>'
- define target '<def[object].entity_type>'
- define eLoc '<def[object].location>'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Entity_Target_Entity:
type: world
debug: false
eventHooks: entity_target_entity|entity_target_player|entity_target_npc|entity_target_armorstand|entity_target_itemframe|npc_target_npc|npc_target_player|npc_target_entity|npc_target_itemframe|npc_target_armorstand
events:
on entity targets entity:
# - define atype '<t[<c.entity.is_npc>]:npc||<c.entity.prefix>>'
- if !<c.entity.is_spawned> || !<c.target.is_spawned> {
- queue clear
}
- if <c.entity.is_npc> {
- define atype 'npc'
}
else {
- define atype '<c.entity.prefix>'
}
# - define dtype '<t[<c.target.is_npc>]:npc||<t[<li@armor_stand|item_frame.contains[<c.target.entity_type>]>]:<c.target.entity_type.replace[_]>||<c.target.prefix>>>'
- if <c.target.is_npc> {
- define dtype 'npc'
}
else if <c.target.entity_type> == armor_stand {
- define dtype 'armorstand'
}
else if <c.target.entity_type> == item_frame {
- define dtype 'itemframe'
}
else {
- define dtype '<c.target.prefix>'
}
- define attacker '<c.entity>'
- define defender '<c.target>'
- define world '<c.target.world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[attacker].location.cuboids.include[<def[defender].location.cuboids>].deduplicate.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[%atype%_target_%dtype%]||li@>':
- define flag '%value%'
- define object '<def[<s@dRegions_Flag_%flag%.yaml_key[event_target]>]>'
- define player '<def[<s@dRegions_Flag_%flag%.yaml_key[event_player]||object>]>'
- define target '<def[object].entity_type>'
- define eLoc '<def[object].location>'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Entity_Explode:
type: world
debug: false
events:
on entity explodes:
- define readPath 'entity.explode'
- define target '<c.entity.entity_type>'
- define eLoc '<c.entity.location>'
- define world '<def[eLoc].world.name>'
- inject s@dRegions p:event_PreProc_Config
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[entity_explode]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Entity_Change_Block:
type: world
debug: false
events:
on entity changes block:
# Maybe we want to check block changes here for explosions?
# It's currently disabled because even if the explosion is cancelled, the block
# change event(s) still fire (yes, one explosion can have multiple block changes)
- - if <c.old_material.bukkit_enum> == soil || li@falling_block|creeper|primed_tnt contains <c.entity.entity_type> {
+ - if <c.old_material.bukkit_enum> == soil || li@falling_block|creeper|primed_tnt|unknown contains <c.entity.entity_type||unknown> {
- queue clear
}
+ # This is generic rateLimiter and does not run a full allow/deny flag process. It is required due to the high frequency of snowmen.
- if <c.entity.is_spawned.not> queue clear
- if <c.entity.has_flag[dRegions.EntityGrief]> {
- if <c.entity.flag[dRegions.EntityGrief]> {
- queue clear
}
- determine cancelled
}
- define object '<c.entity>'
- define target '<c.entity.entity_type>'
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define readPath 'entity.changeBlock'
- inject s@dRegions p:event_PreProc_Config
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[entity_change_block]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Fallingblock_Change_Block:
type: world
debug: false
eventHooks: falling_sand|falling_gravel
events:
on falling_block changes block:
- if <c.entity.is_spawned.not> queue clear
- if <c.entity.has_flag[dRegions.EntityGrief]> {
- if <c.entity.flag[dRegions.EntityGrief]> {
- queue clear
}
- determine cancelled
}
- define mat '<c.entity.fallingblock_material.bukkit_enum>'
- if li@sand|gravel !contains %mat% queue clear
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define readPath 'physics.%mat%'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[falling_%mat%]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Entity_Form_Block:
type: world
debug: false
events:
on entity forms block:
- if <c.entity.has_flag[dRegions.EntityGrief]> {
- if <c.entity.flag[dRegions.EntityGrief]> {
- queue clear
}
- determine cancelled
}
- define readPath 'entity.changeBlock'
- define object '<c.entity>'
- define target '<c.entity.entity_type>'
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- inject s@dRegions p:event_PreProc_Config
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[entity_form_block]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
# Handles 3 events: npc_dies entity_dies player_dies
dRegions_Events_Entity_Dies:
type: world
debug: false
eventHooks: npc_dies|entity_dies|player_dies
events:
on entity dies:
# - define target '<t[<c.entity.is_npc>]:npc||<c.entity.prefix>>'
- if <c.entity.is_npc> {
- define target 'npc'
}
else {
- define target '<c.entity.prefix>'
}
# - define player '<t[<def[target].equals_case_sensitive[Player]>]:<c.entity>||null>'
- if '%target%' == 'Player' {
- define player '<c.entity>'
}
else {
- define player 'null'
}
- define object '<c.entity>'
- define eLoc '<def[object].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[%target%_dies]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Entity_Trample_Crops:
type: world
debug: false
eventHooks: entity_trample_crops|player_trample_crops
events:
on entity changes soil:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define type '<c.entity.prefix>'
- define readPath 'trample-crops.%type%'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[%type%_trample_crops]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Entity_Break_Hanging:
type: world
debug: false
eventHooks: entity_break_itemframe|entity_break_painting
events:
on entity breaks hanging:
- if <c.entity.prefix> == player {
- queue clear
}
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define type '<c.hanging.entity_type.replace[_]>'
- define readPath 'entity-break-%type%'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[entity_break_%type%]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
#
################################################################################
#
# World Events
#
dRegions_Events_Block_Ignites:
type: world
debug: false
eventHooks: lava_fire|fire_spread
events:
on block ignites:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define target '<c.material.bukkit_enum>'
- define readPath 'fire.<c.cause>'
- choose '<c.cause>':
- case 'ENDER_CRYSTAL':
- define entity '<c.entity>'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- case 'EXPLOSION':
- define entity '<c.entity>'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- case 'FIREBALL':
- define entity '<c.entity>'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- case 'FLINT_AND_STEEL':
- define player '<c.entity>'
- if <def[player].permission[dregions.admin]||false> || <def[player].is_op> {
- queue clear
}
- inject s@dRegions p:event_PreProc_Config-NoTarget
- case 'LAVA':
- inject s@dRegions p:event_PreProc_Config
- case 'SPREAD':
- inject s@dRegions p:event_PreProc_Config
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[fireFrom_<c.cause>]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Block_Burns:
type: world
debug: false
eventHooks: block_burns
events:
on block burns:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define target '<c.material.bukkit_enum>'
- define readPath 'fire.destroyBlocks'
- inject s@dRegions p:event_PreProc_Config
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[block_burns]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Ice_Forms:
type: world
debug: false
eventHooks: blockform_ice
events:
on ice forms:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define readPath 'blockform.ice'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[blockform_ice]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Snow_Form:
type: world
debug: false
eventHooks: blockform_snow
events:
on snow forms:
+ # This tries to account for snowmen but can result in snow forming on restricted blocks as the entity grief flag is effectively responsible for the event.
- define cub 'cu@<c.location>|<c.location.add[0,1,0]>'
- if !<def[cub].list_entities[snowman].is_empty> {
- queue clear
}
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define target '<def[eLoc].sub[0,1,0].material.bukkit_enum>'
- define readPath 'blockform.snow'
- inject s@dRegions p:event_PreProc_Config
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[blockform_snow]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Soil_Fades:
type: world
debug: false
eventHooks: blockfade_soil
events:
on soil fades:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define readPath 'blockfade.soil'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[blockfade_soil]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Ice_Fades:
type: world
debug: false
eventHooks: blockfade_ice
events:
on ice fades:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define readPath 'blockfade.ice'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[blockfade_ice]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Snow_Fades:
type: world
debug: false
eventHooks: blockfade_snow
events:
on snow fades:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define readPath 'blockfade.snow'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[blockfade_snow]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Block_Spread:
type: world
debug: false
eventHooks: blockspread_grass|blockspread_mycel|blockspread_mushroom|blockspread_vines
events:
on block spreads:
- define mat '<c.material.bukkit_enum.split[_].last>'
- if li@grass|mycel|mushroom|vines !contains %mat% queue clear
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define readPath 'spread.%mat%'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[blockspread_%mat%]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Liquid_Spread:
type: world
debug: false
eventHooks: water_spreads|lava_spreads
events:
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>'
- if li@water|lava !contains %mat% queue clear
- define eLoc '<c.destination>'
- define target '<c.destination.material.bukkit_enum>'
- define world '<c.location.world.name>'
- define readPath 'spread.%mat%'
- inject s@dRegions p:event_PreProc_Config
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
# Block liquid from crossing region borders
- if '<c.location.cuboids>' != '<c.destination.cuboids>' {
- define regionPri 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<c.location.cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>' {
- define regionPri '%regionPri%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
}
- if '<def[orderedRegions].get[1]>' != '<def[regionPri].alphanumeric.reverse.parse[after[/]].get[1]>' {
- determine cancelled
}
}
- foreach '<yaml[dRegions_eventmap].read[%mat%_spread]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Lightning_Strikes:
type: world
debug: false
eventHooks: lightning_strikes
events:
on lightning strikes:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define target '<c.location.below.material.bukkit_enum>'
- define readPath 'lightning-strike'
- inject s@dRegions p:event_PreProc_Config
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[lightning_strikes]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Leaf_Decay:
type: world
debug: false
eventHooks: blockfade_leaves
events:
on leaves decay:
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define readPath 'blockfade.leaves'
- inject s@dRegions p:event_PreProc_Config-NoTarget
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[blockfade_leaves]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
# Was testing an alternate method. It took an average of 1ms longer :/
# - define ftype '<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
# - define cache '<parse:<def[orderedRegions].parse[replace[regex:^].with[<<>yaml<&lb>dRegions_%world%_cache<&rb>.read<&lb>cache.%ftype%.]].parse[replace[regex:$].with[.%flag%<&rb>||null<>>]]>>'
# - define cache '<def[cache].filter[is[!=].to[null]]>'
# - if <def[cache].size> == '0' {
# - inject 's@dRegions_Flags_Processors' 'p:%ftype%'
# - foreach next
# }
# - define cache '<def[cache].filter[is[!=].to[none]].get[1]||true>'
# - if '%cache%' {
# - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
# - inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
# }
# - foreach next
# }
# - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-cancelled' {
# - inject 's@dRegions_Flag_%flag%' 'p:event-cancelled'
# }
# - if <def[noCancel].exists> {
# - foreach next
# - queue clear
# }
# - determine cancelled
dRegions_Events_Potion_Splash:
type: world
debug: false
eventHooks: potion_splash
events:
on potion splash:
- define player 'null'
- define eLoc '<c.location>'
- define cuboids '<c.entities.parse[location.cuboids].deduplicate>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<c.entities.parse[location.cuboids].deduplicate.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '<yaml[dRegions_eventmap].read[potion_splash]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Pistons:
type: world
debug: false
eventHooks: piston_extend|piston_retract
events:
on piston extends:
# - define lastBlock '<tern[<c.length.is[==].to[0]||true>]:<c.relative>||<c.relative.sub[<c.location>].add[<c.blocks.last>]>>'
- if <c.length||0> == 0 {
- define lastBlock <c.relative>
}
else {
- define lastBlock <c.relative.sub[<c.location>].add[<c.blocks.last>]>
}
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define originRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define originRegions '%originRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define originRegions '<def[originRegions].alphanumeric.reverse.parse[after[/]]>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<c.blocks.include[%lastBlock%].parse[cuboids.separated_by[|]].deduplicate.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
# Block piston blocks from crossing region borders
- if '<def[orderedRegions].get[1]>' != '<def[originRegions].get[1]>' {
- determine cancelled
}
- foreach '<yaml[dRegions_eventmap].read[piston_extend]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
on piston retracts:
# - define lastBlock '<tern[<c.length.is[==].to[0]||true>]:<c.relative>||<c.relative.sub[<c.location>].add[<c.blocks.last>]>>'
- if <c.length||0> == 0 {
- define lastBlock <c.relative>
}
else {
- define lastBlock <c.relative.sub[<c.location>].add[<c.blocks.last>]>
}
- define eLoc '<c.location>'
- define world '<def[eLoc].world.name>'
- define originRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define originRegions '%originRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define originRegions '<def[originRegions].alphanumeric.reverse.parse[after[/]]>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<c.blocks.include[%lastBlock%].parse[cuboids.separated_by[|]].deduplicate.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
# Block piston blocks from crossing region borders
- if '<def[orderedRegions].get[1]>' != '<def[originRegions].get[1]>' {
- determine cancelled
}
- foreach '<yaml[dRegions_eventmap].read[piston_retract]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
dRegions_Events_Issue_Command:
type: world
debug: false
eventHooks: player_command|server_command
events:
on command:
# - define type '<t[<c.server||false>]:server||player>'
- define target '<c.command.to_lowercase> <c.raw_args.to_lowercase>'
- define target '<def[target].escaped>'
- define delimiter ' ; '
- if <c.server> {
- define type 'server'
- goto 'FLAGS'
}
- define type 'player'
- define player '<player>'
- define eLoc '<def[player].location>'
- define world '<def[eLoc].world.name>'
- define orderedRegions 'li@<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[eLoc].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- mark 'FLAGS'
- foreach '<yaml[dRegions_eventmap].read[%type%_command]||li@>':
- define flag '%value%'
- - inject 's@dRegions_Flags_Processors' 'p:<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
+ - inject 's@dRegions_Flags_Processors_<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
#
################################################################################
#
# dRegions Other Utilities
#
# Other Utility functions used throughout dRegions
#
#--------------------------------------
#
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.
# Since this method is shared by highestOnly and orderedRegions lookups we can not return the default flag value.
# Doing so would interfere with the orderedRegions lookup. Flag processors are responsible for looking up defaults
# after they have traversed all applicable regions.
# <proc[dRegions_GetInheritedFlag].context[world|region|flag]>
type: procedure
definitions: world|region|flag
debug: false
script:
- define return '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%]||none>'
- while '<def[return].equals_case_sensitive[none]>':
- if <yaml[dRegions_%world%_regions].contains[regions.%region%.parent]> {
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]>'
- define return '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%]||none>'
- while next
}
- while stop
- determine '%return%'
# - determine '<t[<def[return].equals_case_sensitive[n].not>]:%return%||<s@dRegions_Flag_%flag%.yaml_key[flag_<t[<def[region].equals_case_sensitive[__global__]>]:global||region>Default]||none>>'
# - if %return% == 'none' {
# - if %region% == '__global__' {
# - determine '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
# }
# - determine '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
# }
#--------------------------------------
#
dRegions_FlagLookup_H:
# Get a flag value at a location. For use with flags that set highestOnly.
# If the location does not set the flag value, lookup the default set in the flagscript.
# <proc[dRegions_FlagLookup_H].context[flag|location]>
type: procedure
definitions: flag|loc
debug: false
script:
- define w '<def[loc].world.name>'
# - define orderedRegions '<def[loc].cuboids.filter[starts_with[cu@dregions_%w%_]].parse[after[cu@dregions_%w%_]].include[<yaml[dRegions_%w%_regions].read[regions.__global__.priority]||0>/__global__]>'
# - define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- define orderedRegions 'li@<yaml[dRegions_%w%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[loc].cuboids.filter[starts_with[cu@dregions_%w%]].parse[after[cu@dregions_%w%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%w%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- define region '<def[orderedRegions].get[1]>'
- define return '<yaml[dRegions_%w%_regions].read[regions.%region%.flags.%flag%]||none>'
- define child '%region%'
- while '<def[return].equals_case_sensitive[none]>':
- if <yaml[dRegions_%w%_regions].contains[regions.%child%.parent]> {
- define child '<yaml[dRegions_%w%_regions].read[regions.%child%.parent]>'
- define return '<yaml[dRegions_%w%_regions].read[regions.%child%.flags.%flag%]||none>'
}
else {
- while stop
}
- if '%return%' == 'none' {
- if '%region%' == '__global__' {
- determine '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>/%region%'
}
- determine '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>/%region%'
}
- determine '%return%/%region%'
#
#---------------------------------------
#
dRegions_FlagLookup_O:
# Get a flag value at a location. For use with flags that traverse orderedRegions.
# If the location does not set the flag value, lookup the default set in the flagscript.
# <proc[dRegions_FlagLookup_O].context[flag|location]>
type: procedure
definitions: flag|loc
debug: false
script:
- define w '<def[loc].world.name>'
# - define orderedRegions '<def[loc].cuboids.filter[starts_with[cu@dregions_%w%_]].parse[after[cu@dregions_%w%_]].include[<yaml[dRegions_%w%_regions].read[regions.__global__.priority]||0>/__global__]>'
# - define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- define orderedRegions 'li@<yaml[dRegions_%w%_regions].read[regions.__global__.priority]||0>/__global__'
- foreach '<def[loc].cuboids.filter[starts_with[cu@dregions_%w%]].parse[after[cu@dregions_%w%_]]>':
- define orderedRegions '%orderedRegions%|<yaml[dRegions_%w%_regions].read[regions.%value%.priority]||0>/%value%'
- define orderedRegions '<def[orderedRegions].alphanumeric.reverse.parse[after[/]]>'
- foreach '%orderedRegions%':
- define region '%value%'
- define return '<yaml[dRegions_%w%_regions].read[regions.%region%.flags.%flag%]||none>'
- define child '%region%'
- while '<def[return].equals_case_sensitive[none]>':
- if <yaml[dRegions_%w%_regions].contains[regions.%child%.parent]> {
- define child '<yaml[dRegions_%w%_regions].read[regions.%child%.parent]>'
- define return '<yaml[dRegions_%w%_regions].read[regions.%child%.flags.%flag%]||none>'
}
else {
- while stop
}
- if '%return%' != 'none' {
- foreach stop
}
- if '%return%' == 'none' {
- if '%region%' == '__global__' {
- determine '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>/%region%'
}
- determine '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>/%region%'
}
- determine '%return%/%region%'
#
#---------------------------------------
#
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
debug: false
script:
- define playerUUID '<def[player].uuid>'
- define playerGroups '<def[player].groups||li@>'
- choose '%group%':
- case 'all':
- determine 'true'
- case 'members':
# - determine '<proc[dRegions_isMember].context[%region%|%world%|%player%]>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
- while '<yaml[dRegions_%world%_regions].contains[regions.%region%.parent]>':
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
- determine 'false'
- case 'nonmembers':
# - determine '<proc[dRegions_isOwner].context[%region%|%world%|%player%].or[<proc[dRegions_isMember].context[%region%|%world%|%player%]>].not>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'false'
}
- while '<yaml[dRegions_%world%_regions].contains[regions.%region%.parent]>':
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'false'
}
- determine 'true'
- case 'owners':
# - determine '<proc[dRegions_isOwner].context[%region%|%world%|%player%]>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
- while '<yaml[dRegions_%world%_regions].contains[regions.%region%.parent]>':
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
- determine 'false'
- case 'nonowners':
# - determine '<proc[dRegions_isOwner].context[%region%|%world%|%player%].not>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'false'
}
- while '<yaml[dRegions_%world%_regions].contains[regions.%region%.parent]>':
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'false'
}
- determine 'true'
#
#---------------------------------------
#
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
debug: false
script:
- define playerUUID '<def[player].uuid>'
- define playerGroups '<def[player].groups||li@>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
# Regions inherit members and owners.
- while '<yaml[dRegions_%world%_regions].contains[regions.%region%.parent]>':
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> || <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
debug: false
script:
- define playerUUID '<def[player].uuid>'
- define playerGroups '<def[player].groups||li@>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
# Regions inherit members and owners.
- while '<yaml[dRegions_%world%_regions].contains[regions.%region%.parent]>':
- define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]>'
- if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> || <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> {
- determine 'true'
}
- determine 'false'
#
#--------------------------------------
#
# Command Permission Check Procedure script
#
# Used to check if a player has permission to use a command.
#
# 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_Command].context[command|player|region|option]>
#
dRegions_HasPerm_Command:
type: procedure
debug: false
definitions: command|player|region|option
script:
- if <player.permission[a]||null> == null {
- if <player.is_op> {
- determine true
}
else {
- determine false
}
}
- if %option% == null {
- inject locally permCheck
}
else {
- inject locally permCheck-%command%
}
permCheck:
- narrate "permCheck <s@dRegions_Commands.yaml_key[commandArgs.%command%.permissions]||li@>"
- if <player.is_op> || <player.permission[dregions.admin]> {
- determine true
}
- define perms "<s@dRegions_Commands.yaml_key[commandArgs.%command%.permissions]||li@>"
- foreach %perms% {
- define perm '<parse:%value%>'
- if <player.permission[%perm%]> {
- determine true
}
}
- determine false
permCheck-flag:
- define flag '%option%'
- narrate "permCheck-flag <parse:<s@dRegions_Commands.yaml_key[commandArgs.%command%.permissions]||li@>>"
- if <player.is_op> || <player.permission[dregions.admin]> {
- determine true
}
- define perms "<s@dRegions_Commands.yaml_key[commandArgs.%command%.permissions]||li@>"
- foreach %perms% {
- define perm '<parse:%value%>'
- narrate "<player.permission[%perm%]> %perm%"
- if <player.permission[%perm%]> {
- determine true
}
}
- determine false
+#
+#---------------------------------------
+#
+dRegions_CloneWord:
+ type: world
+ debug: true
+
+ events:
+ on instance created:
+ - define clone <c.blueprint_world>
+ - define world <c.instance>
+ - if !<server.has_file[dRegions/worlds/%clone%]> {
+ - run s@msgPrefixed instantly delayed:1t 'def:dRegions|<&c>%clone% is an unknown world!'
+ - queue clear
+ }
+ - foreach 'li@config|regions|inventories|cache':
+ - define this '%value%'
+ - define file 'worlds/%clone%/%this%'
+ - if <server.has_file[dRegions/%file%.yml]> {
+ - define readID 'dRegions_%clone%_%this%'
+ - if !<yaml.list.contains[%readID%]> {
+ - yaml 'load:dRegions/%file%.yml' 'id:%readID%'
+ }
+ - define writeID 'dRegions_%world%_%this%'
+ - define readPath '%this%'
+ - define writePath '%this%'
+ - yaml create 'id:%writeID%'
+ - run s@ConfigFileGenerator instantly 'def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false'
+ - yaml 'savefile:dRegions/worlds/%world%/%this%.yml' 'id:%writeID%'
+ }
+ else {
+ - inject s@dRegions create%this%File
+ }
+ - if <yaml.list.contains[%writeID%]> {
+ - yaml unload 'id:%writeID%'
+ }
+ - yaml 'load:dRegions/worlds/%world%/%this%.yml' 'id:%writeID%'
+ - foreach '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__]>':
+ - note 'cu@<yaml[dRegions_%world%_regions].read[regions.%value%.min]>|<yaml[dRegions_%world%_regions].read[regions.%value%.max]>' 'as:dregions_%world%_%value%'
+
+
#
#---------------------------------------
#
dRegions_RegionSort:
# An attempt to sort regions by priority. The existing method is faster.
# Keeping for reference and lulz.
type: procedure
definitions: region1|region2
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_RegionExists:
# A procedure script to check if a region exists
# <proc[dRegions_RegionExists].context[region|world]>
type: procedure
definitions: region|world
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:
# Used sparingly in some commands. Events implement this method directly.
# Filter a list of regions by priority in descending order
# <proc[dRegions_HighestPriority].context[world|region1,...]>
type: procedure
definitions: world|regions
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].separated_by[/].replace[cu@]>|%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
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].as_cuboid>]].parse[replace[cu@dregions_%world%_]]||li@>'
- define orderedRegions '<proc[dRegions_HighestPriority].context[%world%|<def[overlaps].separated_by[,]>]||li@>'
- foreach '%orderedRegions%':
- if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
- determine true
}
- 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_CuboidIsWithinCuboid:
# Not used anywhere since Denizen implemented its own which is faster.
# Keeping for reference.
# Checks if one cuboid is completely within another cuboid
# <proc[dRegions_CuboidIsWithinCuboid].context[inner|outer]>
type: procedure
definitions: inner|outer
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_CanUse_Block:
# Not used internally. It's intended as part of an API for external scripts.
# 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
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].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:
# Not used anywhere, but still fun to look at, though totally bonkers.
# 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
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:
# This should mostly be unused since <proc[lineWrap].context[string|targetLen]>
# exists in MessageConstructorLibrary
# Turn a long string into a list of smaller strings
type: procedure
definitions: string|targetLen
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 '<t[<def[pass].contains[<&nl>]>]:<def[pass].index_of[<&nl>]>||<def[pass].last_index_of[ ]>>'
# - 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>'
}
#
# END other utilities
#--------------------------------------
#
# dRegions author banner items
#
# Banner items representing the authors
#
dRegions_Author_Anthony:
type: item
debug: false
material: i@human_skull
- display name: "<&f> |Anthony|"
+ display name: "<&f> &pipeAnthony&pipe"
+ text_name: '|Anthony|'
+ url: 'http://mineconomy.org'
lore:
- <&7> Owner<&co> <&e>M<&6>ine<&e>C<&6>onomy <&e>N<&6>etwork
- <&5>-------------------------
- <&7>
- - <&7> I\<&sq>ve been playing minecraft
+ - <&7> I<&sq>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 eventHooks to right clicks
#
dRegions_Map_Interactions:
type: yaml data
debug: false
block:
# Containers
chest: player_interact_container
ender_chest: player_interact_container
locked_chest: player_interact_container
trapped_chest: player_interact_container
dispenser: player_interact_container
hopper: player_interact_container
dropper: player_interact_container
# Doors
trap_door: player_interact_door
iron_trapdoor: player_interact_door
wooden_door: player_interact_door
iron_door_block: player_interact_door
spruce_door: player_interact_door
birch_door: player_interact_door
jungle_door: player_interact_door
dark_oak_door: player_interact_door
acacia_door: player_interact_door
fence_gate: player_interact_door
spruce_fence_gate: player_interact_door
birch_fence_gate: player_interact_door
jungle_fence_gate: player_interact_door
dark_oak_fence_gate: player_interact_door
acacia_fence_gate: player_interact_door
# Switches
lever: player_interact_switches
wood_button: player_interact_switches
stone_button: player_interact_switches
wood_plate: player_interact_switches
stone_plate: player_interact_switches
iron_plate: player_interact_switches
gold_plate: player_interact_switches
# Utility Blocks
workbench: player_interact_utilityBlocks
furnace: player_interact_utilityBlocks
burning_furnace: player_interact_utilityBlocks
brewing_stand: player_interact_utilityBlocks
enchantment_table: player_interact_utilityBlocks
anvil: player_interact_utilityBlocks
beacon: player_interact_utilityBlocks
jukebox: player_interact_utilityBlocks
note_block: player_interact_utilityBlocks
# cauldron: useUtility
# tnt: useUtility
# Other blocks that change when clicked regardless of item in hand
flower_pot: player_interact_blocks
cake_block: player_interact_blocks
diode_block_on: player_interact_blocks
diode_block_off: player_interact_blocks
redstone_comparator_off: player_interact_blocks
redstone_comparator_on: player_interact_blocks
block_withItem:
# jukebox: player_interact_utilityBlocks/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: player_interact_utilityBlocks/bucket|water_bucket|glass_bottle
tnt: player_interact_utilityBlocks/flint_and_steel
activator_rail: player_place_vehicle/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
detector_rail: player_place_vehicle/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
powered_rail: player_place_vehicle/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
rails: player_place_vehicle/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
stationary_water: player_place_vehicle/boat
water: player_place_vehicle/boat
mob_spawner: player_interact_blocks/monster_egg
item:
gold_record: jukebox
glass_bottle: cauldron
flint_and_steel: tnt
dye_colors:
black: 0
red: 1
green: 2
brown: 3
blue: 4
purple: 5
cyan: 6
silver: 7
gray: 8
pink: 9
lime: 10
yellow: 11
light_blue: 12
magenta: 13
orange: 14
white: 15
#
# 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.28
clear_cache_on_restart: false
regions:
enable: true
invincibility-removes-mobs: false
invincibility-confuses-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
leaves: true
lightning-strike: true
lightning-strike-list: []
trample-crops:
player: true
entity: 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-withGroup: []
- state-withTarget: []
- state-withTarget-withGroup: []
- state-withTargetString-withGroup: []
+ b: []
+ sg: []
+ st: []
+ stg: []
+ stsg: []
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!
#
-################################################################################
+#################################################################################
#
# dRegions Flag system
#
################################################################################
#
# Region flag pre-processors
#
# * NOTES *
# - Entity flags exist in denizen now and can be used as rate limiters
# - NIGHTMARE flag - enter bed transport to nightmare. Creates a pseudorandom instance. Hunt for a bed to get out.
#
-dRegions_Flags_Processors:
+#---------------------------------------
+#
+# State-withTarget-withGroup
+#
+dRegions_Flags_Processors_stg:
type: task
debug: false
-
+ script:
- state-withTarget-withGroup:
# This is a rate limiter implemented BEFORE caching. The idea here is that if the player and event are in
# the same region (even Global) we can safely expect that the values will be consistent (because we clear
# rateLimit values on region enter/exit). Normal processing will follow if the rateLimit value is stale.
# rateLimit value is stored as a boolean.
# Rate limiter
- if '<def[eLoc].cuboids>' == '<def[player].location.cuboids>' {
- define sameRegion 'true'
- if <def[player].has_flag[dRegions.rateLimit.%flag%.%target%]> {
- define a '<def[player].flag[dRegions.rateLimit.%flag%.%target%]>'
- goto 'b'
}
}
else {
- define sameRegion 'false'
}
# Cache values can be none, true, or false. If the cache is set that means we have already done a flag
# lookup once before and can skip the lookup. Cache values are cleared when regions are modified, and
# optionally on server restart.
# A cache value of none is treated as true, but will allow the lookup process to continue. A cache value
# of true or false stops the lookup process and goes to the determination.
# Return format for %flagObj% is action/group actions: allow deny none group: all members nonmembers owners nonowners
# The /all is added on to the end of the flag object just in case someone doesn't specify the group. It is safely ignored if it is set.
# The uuid and prefix are used to help create a yaml friendly node structure for the cache
- define uuid '<def[player].uuid>'
- define prefix '<def[uuid].substring[1,2]>'
- define listflag '<s@dRegions_Flag_%flag%.yaml_key[flag_targetList]||null>'
# First we check the flag if it only wants the highest priority region.
- if '<s@dRegions_Flag_%flag%.yaml_key[region_highestOnly]||false>' {
- define thisRegion '<def[orderedRegions].get[1]>'
- - if <yaml[dRegions_%world%_cache].contains[cache.state-withTarget-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.state-withTarget-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]>'
+ - if <yaml[dRegions_%world%_cache].contains[cache.stg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]> {
+ - define a '<yaml[dRegions_%world%_cache].read[cache.stg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]>'
- goto 'a'
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>/all'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%listflag%].split_by[, ]>'
- if <def[flagObj].starts_with[none]> {
- if '%thisRegion%' == '__global__' {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>/all'
}
else {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>/all'
}
}
- if '%targetList%' == 'li@none' {
- if '%thisRegion%' == '__global__' {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_globalDefault].split_by[, ]||none>'
}
else {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_regionDefault].split_by[, ]||none>'
}
}
# - define c '<def[targetList].contains_any[none|all|%target%].and[<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].after[/].before[/]>|%thisRegion%|%world%|%player%]>]>'
- if '<def[targetList].contains_any[none|all|%target%]>' && '<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].after[/].before[/]>|%thisRegion%|%world%|%player%]>' {
- define c 'true'
}
else {
- define c 'false'
}
# - define a '<t[<def[flagObj].starts_with[deny]>]:<def[c].not>||%c%>'
- if <def[flagObj].starts_with[deny]> {
- define a '<def[c].not>'
}
else {
- define a '%c%'
}
- - yaml set 'cache.state-withTarget-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.stg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
- goto 'a'
}
# Parse %orderedRegions% until the %flagObj% has a value. Not sure if %targetList% should be filled independently, only in
# relation to %thisRegion%, or as it is now where it settles on the first none empty value.
- define targetlist 'li@none'
- define s '<def[orderedRegions].size>'
- foreach '%orderedRegions%':
- define thisRegion '%value%'
- - if <yaml[dRegions_%world%_cache].contains[cache.state-withTarget-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.state-withTarget-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]>'
+ - if <yaml[dRegions_%world%_cache].contains[cache.stg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]> {
+ - define a '<yaml[dRegions_%world%_cache].read[cache.stg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]>'
- if '%a%' == 'none' {
- define a 'true'
- foreach next
}
- goto 'a'
}
# - define targetList '<t[<def[targetList].is[==].to[li@none]>]:<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%listflag%].split_by[, ]>||%targetList%>'
- if '%targetList%' == 'li@none' {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%listflag%].split_by[, ]>'
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>/all'
- if %loop_index% != %s% {
- if <def[flagObj].starts_with[none]> {
- define a 'true'
- - yaml set 'cache.state-withTarget-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:none' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.stg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:none' 'id:dRegions_%world%_cache'
- foreach next
}
}
- if <def[flagObj].starts_with[none]> {
- if '%thisRegion%' == '__global__' {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>/all'
}
else {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>/all'
}
}
- if '%targetList%' == 'li@none' {
- if '%thisRegion%' == '__global__' {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_globalDefault].split_by[, ]||none>'
}
else {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_regionDefault].split_by[, ]||none>'
}
}
# - define c '<def[targetList].contains_any[none|all|%target%].and[<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].after[/].before[/]>|%thisRegion%|%world%|%player%]>]>'
- if '<def[targetList].contains_any[none|all|%target%]>' && '<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].after[/].before[/]>|%thisRegion%|%world%|%player%]>' {
- define c 'true'
}
else {
- define c 'false'
}
# - define a '<t[<def[flagObj].starts_with[deny]>]:<def[c].not>||%c%>'
- if <def[flagObj].starts_with[deny]> {
- define a '<def[c].not>'
}
else {
- define a '%c%'
}
- - yaml set 'cache.state-withTarget-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.stg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
- foreach stop
# Set the rateLimit if applicable
- mark 'a'
- if %sameRegion% {
- flag %player% 'dRegions.rateLimit.%flag%.%target%:%a%'
}
# Process determinations
- mark 'b'
- if '%a%' {
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
- inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
}
- foreach next
- queue clear
}
+ - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'msg_cancelled' {
+ - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
+ - flag %player% dRegions.Message_Cooldown duration:3s
+ - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o><parse:<s@dRegions_Flag_%flag%.yaml_key[msg_cancelled]||null>>'
+ }
+ }
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-cancelled' {
- inject 's@dRegions_Flag_%flag%' 'p:event-cancelled'
}
- if <def[noCancel].exists> {
- foreach next
- queue clear
}
- determine cancelled
#
-# END state-withTarget-withGroup
+# END stg
#---------------------------------------
#
- state-withTarget:
+# State-withTarget
+#
+dRegions_Flags_Processors_st:
+ type: task
+ debug: false
+ script:
- define listflag '<s@dRegions_Flag_%flag%.yaml_key[flag_targetList]||null>'
- if '<s@dRegions_Flag_%flag%.yaml_key[region_highestOnly]||false>' {
- define thisRegion '<def[orderedRegions].get[1]>'
- - if <yaml[dRegions_%world%_cache].contains[cache.state-withTarget.%thisRegion%.%flag%.%target%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%thisRegion%.%flag%.%target%]>'
+ - if <yaml[dRegions_%world%_cache].contains[cache.st.%thisRegion%.%flag%.%target%]> {
+ - define a '<yaml[dRegions_%world%_cache].read[cache.st.%thisRegion%.%flag%.%target%]>'
- goto 'a'
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%listflag%].split_by[, ]>'
- if '%flagObj%' == 'none' {
- if '%thisRegion%' == '__global__' {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
}
else {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
}
}
- if '%targetList%' == 'li@none' {
- if '%thisRegion%' == '__global__' {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_globalDefault].split_by[, ]||none>'
}
else {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_regionDefault].split_by[, ]||none>'
}
}
- define c '<def[targetList].contains_any[none|all|%target%]>'
- if '%flagObj%' == 'deny' {
- define a '<def[c].not>'
}
else {
- define a '%c%'
}
- - yaml set 'cache.state-withTarget.%thisRegion%.%flag%.%target%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.st.%thisRegion%.%flag%.%target%:%a%' 'id:dRegions_%world%_cache'
- goto 'a'
}
- define targetlist 'li@none'
- define s '<def[orderedRegions].size>'
- foreach '%orderedRegions%':
- define thisRegion '%value%'
- - if <yaml[dRegions_%world%_cache].contains[cache.state-withTarget.%thisRegion%.%flag%.%target%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%thisRegion%.%flag%.%target%]>'
+ - if <yaml[dRegions_%world%_cache].contains[cache.st.%thisRegion%.%flag%.%target%]> {
+ - define a '<yaml[dRegions_%world%_cache].read[cache.st.%thisRegion%.%flag%.%target%]>'
- if '%a%' == 'none' {
- define a 'true'
- foreach next
}
- goto 'a'
}
- if '%targetList%' == 'li@none' {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%listflag%].split_by[, ]>'
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
- if %loop_index% != %s% {
- if '%flagObj%' == 'none' {
- define a 'true'
- - yaml set 'cache.state-withTarget.%thisRegion%.%flag%.%target%:none' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.st.%thisRegion%.%flag%.%target%:none' 'id:dRegions_%world%_cache'
- foreach next
}
}
- if '%flagObj%' == 'none' {
- if '%thisRegion%' == '__global__' {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
}
else {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
}
}
- if '%targetList%' == 'li@none' {
- if '%thisRegion%' == '__global__' {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_globalDefault].split_by[, ]||none>'
}
else {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_regionDefault].split_by[, ]||none>'
}
}
- define c '<def[targetList].contains_any[none|all|%target%]>'
- if '%flagObj%' == 'deny' {
- define a '<def[c].not>'
}
else {
- define a '%c%'
}
- - yaml set 'cache.state-withTarget.%thisRegion%.%flag%.%target%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.st.%thisRegion%.%flag%.%target%:%a%' 'id:dRegions_%world%_cache'
- foreach stop
- mark 'a'
- if '%a%' {
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
- inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
}
- foreach next
- queue clear
+ }
+ - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'msg_cancelled' {
+ - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
+ - flag %player% dRegions.Message_Cooldown duration:3s
+ - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o><parse:<s@dRegions_Flag_%flag%.yaml_key[msg_cancelled]||null>>'
+ }
}
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-cancelled' {
- inject 's@dRegions_Flag_%flag%' 'p:event-cancelled'
}
- if <def[noCancel].exists> {
- foreach next
- queue clear
}
- determine cancelled
#
-# END state-withTarget
+# END st
#---------------------------------------
#
- state-withGroup:
+# State-withGroup
+#
+dRegions_Flags_Processors_sg:
+ type: task
+ debug: false
+ script:
- if '<def[eLoc].cuboids>' == '<def[player].location.cuboids>' {
- define sameRegion 'true'
- if <def[player].has_flag[dRegions.rateLimit.%flag%]> {
- define a '<def[player].flag[dRegions.rateLimit.%flag%]>'
- goto 'b'
}
}
else {
- define sameRegion 'false'
}
- define uuid '<def[player].uuid>'
- define prefix '<def[uuid].substring[1,2]>'
- if '<s@dRegions_Flag_%flag%.yaml_key[region_highestOnly]||false>' {
- define thisRegion '<def[orderedRegions].get[1]>'
- - if <yaml[dRegions_%world%_cache].contains[cache.state-withGroup.%thisRegion%.%flag%.%prefix%.%uuid%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.state-withGroup.%thisRegion%.%flag%.%prefix%.%uuid%]>'
+ - if <yaml[dRegions_%world%_cache].contains[cache.sg.%thisRegion%.%flag%.%prefix%.%uuid%]> {
+ - define a '<yaml[dRegions_%world%_cache].read[cache.sg.%thisRegion%.%flag%.%prefix%.%uuid%]>'
- goto 'a'
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>/all'
- if <def[flagObj].starts_with[none]> {
- if '%thisRegion%' == '__global__' {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>/all'
}
else {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>/all'
}
}
- define c '<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].after[/].before[/]>|%thisRegion%|%world%|%player%]>'
# - define a '<t[<def[flagObj].starts_with[deny]>]:<def[c].not>||%c%>'
- if <def[flagObj].starts_with[deny]> {
- define a '<def[c].not>'
}
else {
- define a '%c%'
}
- - yaml set 'cache.state-withGroup.%thisRegion%.%flag%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.sg.%thisRegion%.%flag%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
- goto 'a'
}
- define s '<def[orderedRegions].size>'
- foreach '%orderedRegions%':
- define thisRegion '%value%'
- - if <yaml[dRegions_%world%_cache].contains[cache.state-withGroup.%thisRegion%.%flag%.%prefix%.%uuid%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.state-withGroup.%thisRegion%.%flag%.%prefix%.%uuid%]>'
+ - if <yaml[dRegions_%world%_cache].contains[cache.sg.%thisRegion%.%flag%.%prefix%.%uuid%]> {
+ - define a '<yaml[dRegions_%world%_cache].read[cache.sg.%thisRegion%.%flag%.%prefix%.%uuid%]>'
- if '%a%' == 'none' {
- define a 'true'
- foreach next
}
- goto 'a'
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>/all'
- if %loop_index% != %s% {
- if <def[flagObj].starts_with[none]> {
- define a 'true'
- - yaml set 'cache.state-withGroup.%thisRegion%.%flag%.%prefix%.%uuid%:none' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.sg.%thisRegion%.%flag%.%prefix%.%uuid%:none' 'id:dRegions_%world%_cache'
- foreach next
}
}
- if <def[flagObj].starts_with[none]> {
- if '%thisRegion%' == '__global__' {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>/all'
}
else {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>/all'
}
}
- define c '<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].after[/].before[/]>|%thisRegion%|%world%|%player%]>'
# - define a '<t[<def[flagObj].starts_with[deny]>]:<def[c].not>||%c%>'
- if <def[flagObj].starts_with[deny]> {
- define a '<def[c].not>'
}
else {
- define a '%c%'
}
- - yaml set 'cache.state-withGroup.%thisRegion%.%flag%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.sg.%thisRegion%.%flag%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
- foreach stop
- mark 'a'
- if %sameRegion% {
- flag %player% 'dRegions.rateLimit.%flag%:%a%'
}
- mark 'b'
- if '%a%' {
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
- inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
}
- foreach next
- queue clear
+ }
+ - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'msg_cancelled' {
+ - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
+ - flag %player% dRegions.Message_Cooldown duration:3s
+ - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o><parse:<s@dRegions_Flag_%flag%.yaml_key[msg_cancelled]||null>>'
+ }
}
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-cancelled' {
- inject 's@dRegions_Flag_%flag%' 'p:event-cancelled'
}
- if <def[noCancel].exists> {
- foreach next
- queue clear
}
- determine cancelled
#
-# END state-withGroup
+# END sg
#---------------------------------------
+#
+# State-withTargetString-withGroup
#
- state-withTargetString-withGroup:
+dRegions_Flags_Processors_stsg:
+ type: task
+ debug: false
+ script:
- if '<def[eLoc].cuboids>' == '<def[player].location.cuboids>' {
- define sameRegion 'true'
- if <def[player].has_flag[dRegions.rateLimit.%flag%.%target%]> {
- define a '<def[player].flag[dRegions.rateLimit.%flag%.%target%]>'
- goto 'b'
}
}
else {
- define sameRegion 'false'
}
- define uuid '<def[player].uuid>'
- define prefix '<def[uuid].substring[1,2]>'
- define listflag '<s@dRegions_Flag_%flag%.yaml_key[flag_targetList]||null>'
- if '<s@dRegions_Flag_%flag%.yaml_key[region_highestOnly]||false>' {
- define thisRegion '<def[orderedRegions].get[1]>'
- - if <yaml[dRegions_%world%_cache].contains[cache.state-withTargetString-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.state-withTargetString-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]>'
+ - if <yaml[dRegions_%world%_cache].contains[cache.stsg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]> {
+ - define a '<yaml[dRegions_%world%_cache].read[cache.stsg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]>'
- goto 'a'
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>/all'
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%listflag%].split_by[<def[delimiter]||, >]>'
- if <def[flagObj].starts_with[none]> {
- if '%thisRegion%' == '__global__' {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>/all'
}
else {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>/all'
}
}
- if '%targetList%' == 'li@none' {
- if '%thisRegion%' == '__global__' {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_globalDefault].split_by[<def[delimiter]||, >]||none>'
}
else {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_regionDefault].split_by[<def[delimiter]||, >]||none>'
}
}
- if '<def[targetList].contains_any[none|all|%target%]>' && '<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].after[/].before[/]>|%thisRegion%|%world%|%player%]>' {
- define c 'true'
}
else {
- define c 'false'
}
- if <def[flagObj].starts_with[deny]> {
- define a '<def[c].not>'
}
else {
- define a '%c%'
}
- - yaml set 'cache.state-withTargetString-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.stsg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
- goto 'a'
}
- define targetlist 'li@none'
- define s '<def[orderedRegions].size>'
- foreach '%orderedRegions%':
- define thisRegion '%value%'
- - if <yaml[dRegions_%world%_cache].contains[cache.state-withTargetString-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.state-withTargetString-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]>'
+ - if <yaml[dRegions_%world%_cache].contains[cache.stsg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]> {
+ - define a '<yaml[dRegions_%world%_cache].read[cache.stsg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%]>'
- if '%a%' == 'none' {
- define a 'true'
- foreach next
}
- goto 'a'
}
- if '%targetList%' == 'li@none' {
- define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%listflag%].split_by[<def[delimiter]||, >]>'
}
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>/all'
- if %loop_index% != %s% {
- if <def[flagObj].starts_with[none]> {
- define a 'true'
- - yaml set 'cache.state-withTargetString-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:none' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.stsg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:none' 'id:dRegions_%world%_cache'
- foreach next
}
}
- if <def[flagObj].starts_with[none]> {
- if '%thisRegion%' == '__global__' {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>/all'
}
else {
- define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>/all'
}
}
- if '%targetList%' == 'li@none' {
- if '%thisRegion%' == '__global__' {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_globalDefault].split_by[<def[delimiter]||, >]||none>'
}
else {
- define targetList '<s@dRegions_Flag_%listflag%.yaml_key[flag_regionDefault].split_by[<def[delimiter]||, >]||none>'
}
}
- if '<def[targetList].contains_any[none|all|%target%]>' && '<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].after[/].before[/]>|%thisRegion%|%world%|%player%]>' {
- define c 'true'
}
else {
- define c 'false'
}
- if <def[flagObj].starts_with[deny]> {
- define a '<def[c].not>'
}
else {
- define a '%c%'
}
- - yaml set 'cache.state-withTargetString-withGroup.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.stsg.%thisRegion%.%flag%.%target%.%prefix%.%uuid%:%a%' 'id:dRegions_%world%_cache'
- foreach stop
- mark 'a'
- if %sameRegion% {
- flag %player% 'dRegions.rateLimit.%flag%.%target%:%a%'
}
- mark 'b'
- if '%a%' {
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
- inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
}
- foreach next
- queue clear
+ }
+ - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'msg_cancelled' {
+ - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
+ - flag %player% dRegions.Message_Cooldown duration:3s
+ - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o><parse:<s@dRegions_Flag_%flag%.yaml_key[msg_cancelled]||null>>'
+ }
}
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-cancelled' {
- inject 's@dRegions_Flag_%flag%' 'p:event-cancelled'
}
- if <def[noCancel].exists> {
- foreach next
- queue clear
}
- determine cancelled
#
-# END state-withTargetString-withGroup
+# END stsg
#---------------------------------------
#
# Testing an alternate method. This process took an average of 1ms longer AND lackd the ability to set a cache at every level.
# test_boolean:
# - if '<s@dRegions_Flag_%flag%.yaml_key[region_highestOnly]||false>' {
# - define f '<proc[dRegions_FlagLookup_H].context[%flag%|%eLoc%]>'
# }
# else {
# - define f '<proc[dRegions_FlagLookup_O].context[%flag%|%eLoc%]>'
# }
# - define a '<def[f].before[/]>'
# - define thisRegion '<def[f].after[/]>'
# - if '%a%' == 'false' {
# - yaml set 'cache.test_boolean.%thisRegion%.%flag%:false' 'id:dRegions_%world%_cache'
# - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-cancelled' {
# - inject 's@dRegions_Flag_%flag%' 'p:event-cancelled'
# }
# - if <def[noCancel].exists> {
# - foreach next
# - queue clear
# }
# - determine cancelled
# }
# - yaml set 'cache.test_boolean.%thisRegion%.%flag%:true' 'id:dRegions_%world%_cache'
# - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
# - inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
+# }
+#
+#dRegions_Flags_Processors_b:
+# type: task
+# debug: false
+# script:
+# - if '<s@dRegions_Flag_%flag%.yaml_key[region_highestOnly]||false>' {
+# - define thisRegion '<def[orderedRegions].get[1]>'
+# - if <yaml[dRegions_%world%_cache].contains[cache.b.%thisRegion%.%flag%]> {
+# - define a '<yaml[dRegions_%world%_cache].read[cache.b.%thisRegion%.%flag%]>'
+# - goto 'a'
+# }
+# - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
+# - if '%flagObj%' == 'none' {
+# - if '%thisRegion%' == '__global__' {
+# - define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
+# }
+# else {
+# - define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
+# }
+# }
+# - if '%flagObj%' == 'false' {
+# - define a 'false'
+# }
+# else {
+# - define a 'true'
+# }
+# - yaml set 'cache.b.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
+# - goto 'a'
+# }
+# - define s '<def[orderedRegions].size>'
+# - foreach '%orderedRegions%':
+# - define thisRegion '%value%'
+# - if <yaml[dRegions_%world%_cache].contains[cache.b.%thisRegion%.%flag%]> {
+# - define a '<yaml[dRegions_%world%_cache].read[cache.b.%thisRegion%.%flag%]>'
+# - if '%a%' == 'none' {
+# - define a 'true'
+# - foreach next
+# }
+# - goto 'a'
+# }
+# - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
+# - if '%loop_index%' != '%s%' {
+# - if '%flagObj%' == 'none' {
+# - define a 'true'
+# - yaml set 'cache.b.%thisRegion%.%flag%:none' 'id:dRegions_%world%_cache'
+# - foreach next
+# }
+# - define a '%flagObj%'
+# - yaml set 'cache.b.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
+# - goto 'a'
+# }
+# - if '%flagObj%' == 'none' {
+# - if '%thisRegion%' == '__global__' {
+# - define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
+# }
+# else {
+# - define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
+# }
+# }
+# - if '%flagObj%' == 'false' {
+# - define a 'false'
+# }
+# else {
+# - define a 'true'
+# }
+# - yaml set 'cache.b.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
+
+# - mark 'a'
+# - if '%a%' {
+# - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
+# - inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
+# }
+# - foreach next
+# - queue clear
+# }
+# - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'msg_cancelled' {
+# - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
+# - flag %player% dRegions.Message_Cooldown duration:3s
+# - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o><parse:<s@dRegions_Flag_%flag%.yaml_key[msg_cancelled]||null>>'
+# }
+# }
+# - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-cancelled' {
+# - inject 's@dRegions_Flag_%flag%' 'p:event-cancelled'
+# }
+# - if <def[noCancel].exists> {
+# - foreach next
+# - queue clear
# }
+# - determine cancelled
+#---------------------------------------
+#
+# Boolean
#
- boolean:
+dRegions_Flags_Processors_b:
+ type: task
+ debug: false
+ script:
- if '<s@dRegions_Flag_%flag%.yaml_key[region_highestOnly]||false>' {
- define thisRegion '<def[orderedRegions].get[1]>'
- - if <yaml[dRegions_%world%_cache].contains[cache.boolean.%thisRegion%.%flag%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.boolean.%thisRegion%.%flag%]>'
- - goto 'a'
- }
- - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
+ - define a '<yaml[dRegions_%world%_cache].read[cache.b.%thisRegion%.%flag%]||a>'
+ - goto '%a%'
+ - mark 'a'
+ - define a '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
+ - if '%a%' == 'none' {
- - if '%flagObj%' == 'none' {
- if '%thisRegion%' == '__global__' {
- - define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
+ - define a '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
}
else {
- - define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
+ - define a '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
}
}
- - if '%flagObj%' == 'false' {
+ - if '%a%' != 'false' {
- - define a 'false'
- }
- else {
- define a 'true'
}
- - yaml set 'cache.boolean.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
- - goto 'a'
+ - yaml set 'cache.b.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
+ - goto '%a%'
}
- define s '<def[orderedRegions].size>'
- foreach '%orderedRegions%':
- define thisRegion '%value%'
- - if <yaml[dRegions_%world%_cache].contains[cache.boolean.%thisRegion%.%flag%]> {
- - define a '<yaml[dRegions_%world%_cache].read[cache.boolean.%thisRegion%.%flag%]>'
- - if '%a%' == 'none' {
- - define a 'true'
- - foreach next
- }
- - goto 'a'
+ - define a '<yaml[dRegions_%world%_cache].read[cache.b.%thisRegion%.%flag%]||b>'
+ - goto '%a%'
+ - mark 'none'
+ - define a 'true'
+ - foreach next
+ - mark 'b'
+ - define a '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
- }
- - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
- if '%loop_index%' != '%s%' {
- - if '%flagObj%' == 'none' {
- - define a 'true'
- - yaml set 'cache.boolean.%thisRegion%.%flag%:none' 'id:dRegions_%world%_cache'
- - foreach next
- }
+ - yaml set 'cache.b.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
+ - goto '%a%'
+ - mark 'none'
+ - define a 'true'
+ - foreach next
- - define a '%flagObj%'
- - yaml set 'cache.boolean.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
- - goto 'a'
}
- - if '%flagObj%' == 'none' {
+ - if '%a%' == 'none' {
- if '%thisRegion%' == '__global__' {
- - define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
+ - define a '<s@dRegions_Flag_%flag%.yaml_key[flag_globalDefault]||none>'
}
else {
- - define flagObj '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
+ - define a '<s@dRegions_Flag_%flag%.yaml_key[flag_regionDefault]||none>'
}
}
- - if '%flagObj%' == 'false' {
+ - if '%a%' != 'false' {
- - define a 'false'
- }
- else {
- define a 'true'
}
- - yaml set 'cache.boolean.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
+ - yaml set 'cache.b.%thisRegion%.%flag%:%a%' 'id:dRegions_%world%_cache'
+ - goto '%a%'
- - mark 'a'
- - if '%a%' {
- - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
- - inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
+ - mark 'false'
+ - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'msg_cancelled' {
+ - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
+ - flag %player% dRegions.Message_Cooldown duration:3s
+ - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o><parse:<s@dRegions_Flag_%flag%.yaml_key[msg_cancelled]||null>>'
}
- - foreach next
- - queue clear
}
- if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-cancelled' {
- inject 's@dRegions_Flag_%flag%' 'p:event-cancelled'
}
- if <def[noCancel].exists> {
- foreach next
- queue clear
}
- determine cancelled
+ - mark 'true'
+ - if '<s@dRegions_Flag_%flag%.list_keys>' contains 'event-allowed' {
+ - inject 's@dRegions_Flag_%flag%' 'p:event-allowed'
+ }
#
# END boolean
#---------------------------------------
#
- string:
+dRegions_Flags_Processors_string:
+ type: task
+ debug: false
+ script:
# It is possible to send messages for /any/ dRegions event. Just make a new string flag.
- if '<s@dRegions_Flag_%flag%.yaml_key[region_highestOnly]||false>' {
- define thisRegion '<def[orderedRegions].get[1]>'
- define val '<proc[dRegions_GetInheritedFlag].context[%world%|%thisRegion%|%flag%]>'
- if '%val%' != 'none' {
- goto 'DISPLAY'
}
- goto 'END'
}
- foreach '%orderedRegions%' {
- define thisRegion '%value%'
- define val '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
- if '%val%' != 'none' {
- goto 'DISPLAY'
}
}
- if '%val%' == 'none' {
- goto 'END'
}
- mark 'DISPLAY'
- - choose '<s@dRegions_Flag_%flag%.yaml_key[string-type]||narrate>':
+ - define val '<def[val].replace[<&pc>name<&pc>].with[<def[player].name>].parse_color.replace[<<>].replace[<>>]>'
+ - choose '<s@dRegions_Flag_%flag%.yaml_key[string_type]||narrate>':
- case 'narrate':
- - run s@msgPrefixed 'def:dRegions|<parse:%val%>'
+ - run s@msgPrefixed 'def:dRegions|%val%'
- case 'bossbar':
- - adjust %player% 'action_bar:<parse:%val%>'
+ - adjust %player% 'action_bar:%val%'
- case 'console':
- - announce to_console '<&4>[<&6>dRegions<&4>] <parse:%val%>'
+ - announce to_console '<&4>[<&6>dRegions<&4>] %val%'
- case 'title':
- define title '<def[val].before[/]>'
- define sub '<def[val].after[/]>'
- - title 'title:<parse:%title%>' 'subtitle:<parse:%sub%>'
+ - title 'title:<def[title]>' 'subtitle:<def[sub]>'
- mark 'END'
#
# END string
#---------------------------------------
#
- custom:
+dRegions_Flags_Processors_custom:
+ type: task
+ debug: false
+ script:
- inject 's@dRegions_Flag_%flag%' 'p:event'
#
#
# END custom
#---------------------------------------
#
- number:
+dRegions_Flags_Processors_number:
+ type: task
+ debug: false
+ script:
- inject 's@dRegions_Flag_%flag%' 'p:event'
#
#
# END number
#---------------------------------------
#
- location:
+dRegions_Flags_Processors_location:
+ type: task
+ debug: false
+ script:
- inject 's@dRegions_Flag_%flag%' 'p:event'
#
#
# END location
#---------------------------------------
#
#
#
# END Region Flag Processors
#---------------------------------------
#
################################################################################
#
-# state-withTarget-withGroup Flag Scripts
+# stg Flag Scripts
#
dRegions_Flag_PVE:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>PVE<&4>]"
lore:
- <&5>Can players damage mobs
event_hooks: player_damage_entity
event_priority: 10
event_player: attacker
event_target: defender
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: PVE
flag_targetList: PVE-Moblist
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
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.
+ msg_cancelled: 'You can not attack <def[target].to_lowercase.replace[_].with[ ]>s here!'
event-cancelled:
- remove <c.projectile||li@>
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You can not attack <def[target].to_lowercase.replace[_].with[ ]>s here!'
- }
dRegions_Flag_Mob-Damage:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Damage<&4>]"
lore:
- <&5>Can mobs damage players
event_hooks: entity_damage_player
event_priority: 10
event_player: defender
event_target: attacker
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Mob-Damage
flag_targetList: Mob-DamageList
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
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.
event-cancelled:
- remove <c.projectile||li@>
- attack %object% target:cancel
- if <yaml[dRegions_global_config].read[config.regions.invincibility-confuses-mobs]||false> && <yaml[dRegions_%world%_config].read[config.regions.invincibility-confuses-mobs]||false> {
- run delay:1t locally wander 'def:%object%|%world%'
}
else if <yaml[dRegions_global_config].read[config.regions.invincibility-removes-mobs]||false> && <yaml[dRegions_%world%_config].read[config.regions.invincibility-removes-mobs]||false> {
- remove %object%
}
wander:
- ^adjust %1% has_ai:false
- ^repeat 5 {
- ^if !<def[1].is_spawned||false> {
- queue clear
}
- ~walk %1% '<def[1].location.find.surface_blocks.within[10].filter[distance[<def[1].location>].horizontal.is[more].than[5]].random.add[0,1,0]>'
}
- ^if !<def[1].is_spawned||false> queue clear
- ^if <yaml[dRegions_global_config].read[config.regions.invincibility-removes-mobs]||false> && <yaml[dRegions_%2%_config].read[config.regions.invincibility-removes-mobs]||false> {
- remove %object%
}
else {
- adjust %1% has_ai:false
}
dRegions_Flag_Mob-Target:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Target<&4>]"
lore:
- <&5>Can mobs target players
event_hooks: entity_target_player
event_priority: 0
event_target: attacker
event_player: defender
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Mob-Target
flag_targetList: Mob-TargetList
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
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.
event-cancelled:
- attack %object% target:cancel
- if <yaml[dRegions_global_config].read[config.regions.invincibility-confuses-mobs]||false> && <yaml[dRegions_%world%_config].read[config.regions.invincibility-confuses-mobs]||false> {
- run delay:1t locally wander 'def:%object%|%world%'
}
else if <yaml[dRegions_global_config].read[config.regions.invincibility-removes-mobs]||false> && <yaml[dRegions_%world%_config].read[config.regions.invincibility-removes-mobs]||false> {
- remove %object%
}
wander:
- ^adjust %1% has_ai:false
- ^repeat 5 {
- ^if !<def[1].is_spawned||false> {
- queue clear
}
- ~walk %1% '<def[1].location.find.surface_blocks.within[10].filter[distance[<def[1].location>].horizontal.is[more].than[5]].random.add[0,1,0]>'
}
- ^if !<def[1].is_spawned||false> queue clear
- ^if <yaml[dRegions_global_config].read[config.regions.invincibility-removes-mobs]||false> && <yaml[dRegions_%2%_config].read[config.regions.invincibility-removes-mobs]||false> {
- remove %object%
}
else {
- adjust %1% has_ai:false
}
dRegions_Flag_Entity-Interact:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Entity Interact<&4>]"
lore:
- <&5>Can players interact with entities
event_hooks: player_interact_entity
event_priority: 10
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Entity-Interact
flag_targetList: Entity-Interactlist
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
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.
+ msg_cancelled: 'You can not interact with <def[target].to_lowercase.replace[_].with[ ]>s here!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You can not interact with <def[target].to_lowercase.replace[_].with[ ]>s here!'
- }
-
dRegions_Flag_Block-Place:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Block-Place<&4>]"
lore:
- <&5>Can players place blocks.
event_hooks: player_place_block
event_priority: 5
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Block-Place
flag_targetList: Block-PlaceList
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
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.
+ msg_cancelled: 'You can not place <def[target].to_lowercase.replace[_].with[ ]> in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You can not place <def[target].to_lowercase.replace[_].with[ ]> in this region!'
- }
-
dRegions_Flag_Block-Break:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Block-Break<&4>]"
lore:
- <&5>Can players break blocks.
event_hooks: player_break_block
event_priority: 5
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Block-Break
flag_targetList: Block-BreakList
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
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.
-
+ msg_cancelled: 'You can not break <def[target].to_lowercase.replace[_].with[ ]> in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You can not break <def[target].to_lowercase.replace[_].with[ ]> in this region!'
- }
dRegions_Flag_Chest-Access:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Chest-Access<&4>]"
lore:
- <&5>Can players open containers.
event_hooks: player_interact_container
event_priority: 10
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Chest-Access
flag_targetList: chest-access-blocks
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
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.
+ msg_cancelled: 'You can not open <def[target].to_lowercase.replace[_].with[ ]>s in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You can not open <def[target].to_lowercase.replace[_].with[ ]>s in this region!'
- }
-
dRegions_Flag_Door-Access:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Door-Access<&4>]"
lore:
- <&5>Can players open doors.
event_hooks: player_interact_door
event_priority: 10
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Door-Access
flag_targetList: Door-Access-Doors
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
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.
-
+ msg_cancelled: 'You can not open <def[target].to_lowercase.replace[_].with[ ]>s in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You can not open <def[target].to_lowercase.replace[_].with[ ]>s in this region!'
- }
dRegions_Flag_Use-Switches:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Use-Switches<&4>]"
lore:
- <&5>Can players interact with switches.
event_hooks: player_interact_switches
event_priority: 10
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Use-Switches
flag_targetList: Use-Switches-List
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
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.
-
+ msg_cancelled: 'You can not use <def[target].to_lowercase.replace[_].with[ ]>s in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You can not use <def[target].to_lowercase.replace[_].with[ ]>s in this region!'
- }
dRegions_Flag_Use-Utilities:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Use-Utilities<&4>]"
lore:
- <&5>Can players use utility blocks.
event_hooks: player_interact_utilityBlocks
event_priority: 10
region_highestOnly: true
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Use-Utilities
flag_targetList: Use-Utilities-Blocks
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
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.
+ msg_cancelled: 'You can not use <def[target].to_lowercase.replace[_].with[ ]>s in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You can not use <def[target].to_lowercase.replace[_].with[ ]>s in this region!'
- }
-
dRegions_Flag_Player-Damage:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Damage<&4>]"
lore:
- <&5>Can players take damage.
event_hooks: player_damaged
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget-withGroup
+ flag_type: stg
flag_name: Player-Damage
flag_targetList: Player-Damage-Types
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
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.
event-cancelled:
- adjust %player% 'fire_time:0'
#
-# END state-withTarget-withGroup
+# END stg
#---------------------------------------
#
################################################################################
#
-# State-withTarget Flag Scripts
+# st Flag Scripts
#
dRegions_Flag_Mob-Spawn:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Spawn<&4>]"
lore:
- <&5>Can mobs Spawn
event_hooks: entity_spawn
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Mob-Spawn
flag_targetList: Mob-SpawnList
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
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.
dRegions_Flag_EVE:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>EVE<&4>]"
lore:
- <&5>Can mobs be targeted
event_hooks: entity_target_entity|entity_damage_entity|entity_damage_armorstand
event_priority: 10
event_target: defender
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: EVE
flag_targetList: EVE-Moblist
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
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.
event-cancelled:
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- if <yaml[dRegions_global_config].read[config.regions.invincibility-confuses-mobs]||false> && <yaml[dRegions_%world%_config].read[config.regions.invincibility-confuses-mobs]||false> {
- run delay:1t locally wander 'def:%object%|%world%'
}
else if <yaml[dRegions_global_config].read[config.regions.invincibility-removes-mobs]||false> && <yaml[dRegions_%world%_config].read[config.regions.invincibility-removes-mobs]||false> {
- remove %object%
}
wander:
- ^adjust %1% has_ai:false
- ^repeat 5 {
- ^if !<def[1].is_spawned||false> {
- queue clear
}
- ~walk %1% '<def[1].location.find.surface_blocks.within[10].filter[distance[<def[1].location>].horizontal.is[more].than[5]].random.add[0,1,0]>'
}
- ^if !<def[1].is_spawned||false> queue clear
- ^if <yaml[dRegions_global_config].read[config.regions.invincibility-removes-mobs]||false> && <yaml[dRegions_%2%_config].read[config.regions.invincibility-removes-mobs]||false> {
- remove %object%
}
else {
- adjust %1% has_ai:false
}
dRegions_Flag_Mob-Attack:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Mob-Attack<&4>]"
lore:
- <&5>Can mobs attack other mobs
event_hooks: entity_target_entity|entity_damage_entity|entity_damage_armorstand
event_priority: 20
event_target: attacker
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Mob-Attack
flag_targetList: Mob-Attack-Moblist
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
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.
event-cancelled:
- remove <c.projectile||li@>
- attack %attacker% target:cancel
- if <yaml[dRegions_global_config].read[config.regions.invincibility-confuses-mobs]||false> && <yaml[dRegions_%world%_config].read[config.regions.invincibility-confuses-mobs]||false> {
- run delay:1t locally wander 'def:%object%|%world%'
}
else if <yaml[dRegions_global_config].read[config.regions.invincibility-removes-mobs]||false> && <yaml[dRegions_%world%_config].read[config.regions.invincibility-removes-mobs]||false> {
- remove %object%
}
wander:
- ^adjust %1% has_ai:false
- ^repeat 5 {
- ^if !<def[1].is_spawned||false> {
- queue clear
}
- ~walk %1% '<def[1].location.find.surface_blocks.within[10].filter[distance[<def[1].location>].horizontal.is[more].than[5]].random.add[0,1,0]>'
}
- ^if !<def[1].is_spawned||false> queue clear
- ^if <yaml[dRegions_global_config].read[config.regions.invincibility-removes-mobs]||false> && <yaml[dRegions_%2%_config].read[config.regions.invincibility-removes-mobs]||false> {
- remove %object%
}
else {
- adjust %1% has_ai:false
}
dRegions_Flag_Entity-Explode:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Explode<&4>]"
lore:
- <&5>Can entities explode
event_hooks: entity_explode
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Entity-Explode
flag_targetList: Entity-ExplodeList
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
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.
+ event-allowed:
+ # Block explosions from effecting neighboring dregions
+# - define blocks '<c.blocks.filter[is_within[<def[orderedRegions].get[1].replace[regex:^].with[cu@dregions_%world%_].as_cuboid>]]>'
+ - define cuboids '<c.location.cuboids>'
+ - define thisR '<def[orderedRegions].get[1]>'
+ - define global '<yaml[dRegions_%world%_regions].read[regions.__global__.priority]||0>/__global__'
+ - define final 'li@'
+ - foreach '<c.blocks>':
+ - define l '%value%'
+ - if '%cuboids%' != '<def[l].cuboids>' {
+ - define r 'li@%global%'
+ - foreach '<def[l].cuboids.filter[starts_with[cu@dregions_%world%]].parse[after[cu@dregions_%world%_]]>' {
+ - define r '%r%|<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%'
+ }
+ - if '%thisR%' != '<def[r].alphanumeric.reverse.parse[after[/]].get[1]>' {
+ - foreach next
+ }
+ }
+ - define final '<def[final].include[%l%]>'
+ - determine '%final%'
dRegions_Flag_Entity-Grief:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Grief<&4>]"
lore:
- <&5>Can entities alter blocks
event_hooks: entity_change_block|entity_form_block
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Entity-Grief
flag_targetList: Entity-GriefList
flag_takeGroup: false
flag_regionDefault: deny
flag_globalDefault: allow
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.
event-allowed:
- if <def[object].is_spawned> {
- flag %object% 'dRegions.EntityGrief:true' d:5s
}
event-cancelled:
- if <def[object].is_spawned> {
- flag %object% 'dRegions.EntityGrief:false' d:5s
}
dRegions_Flag_Entity-Drops-OnDeath:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Drops-OnDeath<&4>]"
lore:
- <&5>Can mobs drop items
event_hooks: entity_dies
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Entity-Drops-OnDeath
flag_targetList: Entity-Drops-OnDeathList
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
event-cancelled:
- determine NO_DROPS
dRegions_Flag_Fire-Spread:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Fire-Spread<&4>]"
lore:
- <&5>Can fire spread
event_hooks: firefrom_spread
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Fire-Spread
flag_targetList: Fire-SpreadBlocks
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: allow
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.
dRegions_Flag_Fire-Destroy:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Fire-Destroy<&4>]"
lore:
- <&5>Can fire destroy blocks
event_hooks: block_burns
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Fire-Destroy
flag_targetList: Fire-DestroyBlocks
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: allow
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.
dRegions_Flag_Lightning-Strikes:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Lightning-Strikes<&4>]"
lore:
- <&5>Can lightning strike
event_hooks: lightning_strikes
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Lightning-Strikes
flag_targetList: Lightning-StrikesBlocks
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
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.
dRegions_Flag_Water-Spread:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Water-Spread<&4>]"
lore:
- <&5>Can Water spread
event_hooks: water_spread
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Water-Spread
flag_targetList: Water-SpreadBlocks
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
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.
dRegions_Flag_Lava-Spread:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Lava-Spread<&4>]"
lore:
- <&5>Can Lava spread
event_hooks: lava_spread
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Lava-Spread
flag_targetList: Lava-SpreadBlocks
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
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.
dRegions_Flag_Snow-Fall:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Snow-Fall<&4>]"
lore:
- <&5>Can Snow accumulate
event_hooks: blockform_snow
event_priority: 10
region_highestOnly: false
- flag_type: state-withTarget
+ flag_type: st
flag_name: Snow-Fall
flag_targetList: Snow-FallBlocks
flag_takeGroup: false
flag_regionDefault: allow
flag_globalDefault: allow
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.
#
-# END State-withTarget
+# END st
#---------------------------------------
#
################################################################################
#
-# State-withGroup Flag Scripts
+# sg Flag Scripts
#
dRegions_Flag_Entry:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Entry<&4>]"
lore:
- <&5>Who can enter a region
event_hooks: player_enters_region
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Entry
flag_help: State flag controlling who can enter a region. Can be set to allow, deny, or none and accepts the -g group switch.
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
+ msg_cancelled: 'You may not enter this area!'
event-allowed:
- flag %player% dRegions.rateLimit:!
event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You may not enter this area!'
- }
- if <def[player].is_inside_vehicle> {
- run locally vehicle 'def:<def[player].get_vehicle>|<c.from>' delay:1t
}
vehicle:
- ^if <def[player].has_flag[dRegions.rateLimit.regionKick]> {
- queue clear
}
- ^flag %player% dRegions.rateLimit.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>]:<def[player].location>||<def[2].above>>'
dRegions_Flag_Exit:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Exit<&4>]"
lore:
- <&5>Who can exit a region
event_hooks: player_exits_region
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Exit
flag_help: State flag controlling who can exit a region. Can be set to allow, deny, or none and accepts the -g group switch.
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
+ msg_cancelled: 'You may not exit this area!'
event-allowed:
- flag %player% dRegions.rateLimit:!
event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You may not exit this area!'
- }
- if <def[player].is_inside_vehicle> {
- run locally vehicle 'def:<def[player].get_vehicle>|<c.from>' delay:1t
}
vehicle:
- ^if <def[player].has_flag[dRegions.rateLimit.regionKick]> {
- queue clear
}
- ^flag %player% dRegions.rateLimit.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>]:<def[player].location>||<def[2].above>>'
dRegions_Flag_Build:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Build<&4>]"
lore:
- <&5>Override default build perms
event_hooks: player_place_block|player_break_block|player_place_hanging|player_break_hanging|player_interact_blocks|player_interact_itemframe|player_damage_itemframe|player_use_spawnegg|player_place_armorstand|player_interact_armorstand|player_damage_armorstand|player_throw_hatchingegg|player_empty_bucket|player_fill_bucket|player_extinguish_blockfire|player_use_bonemeal
event_priority: 0
event_player: attacker
event_target: defender
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Build
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
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.
-
+ msg_cancelled: 'You do not have permission to build in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You do not have permission to build in this region!'
- }
dRegions_Flag_Receive-Chat:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Receive-Chat<&4>]"
lore:
- <&5>Who can hear chat
event_hooks: player_entered_dregion|player_exited_dregion
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Receive-Chat
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
flag_help: Control who can hear chat in a region. Takes the -g group switch.
event-cancelled:
- if %isEnter% {
- if !<server.flag[dRegions.Chat.Deaf].as_list.contains[%player%]||false> {
- flag server 'dRegions.Chat.Deaf:->:%player%'
}
}
else {
- flag server 'dRegions.Chat.Deaf:<-:%player%'
}
dRegions_Flag_Send-Chat:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Send-Chat<&4>]"
lore:
- <&5>Who can chat
event_hooks: player_chats
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Send-Chat
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
flag_help: Control who can send chat in a region. Takes the -g group switch.
+ msg_cancelled: 'You can not chat here.'
event-allowed:
- determine 'recipients:<context.recipients.exclude[<server.flag[dRegions.Chat.Deaf].as_list||li@>]>'
-
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not chat here.'
- }
dRegions_Flag_Hunger:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Hunger<&4>]"
lore:
- <&5>Who can get hungry
event_hooks: player_change_foodlevel
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Hunger
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
flag_help: Control whether players will loose hunger in this region. Takes the -g group switch.
dRegions_Flag_Npc-Interact:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>NPC Interact<&4>]"
lore:
- <&5>Can players interact with NPCs
event_hooks: player_interact_npc
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Npc-Interact
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
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.
+ msg_cancelled: 'You can not interact with NPCs here!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not interact with NPCs here!'
- }
-
dRegions_Flag_Lighter:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Lighter<&4>]"
lore:
- <&5>Who can use the flint and steel in a region
# event_hooks: player_use_lighter
event_hooks: fireFrom_flint_and_steel
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Lighter
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to use lighters in this region. Defaults to allow. Takes the -g group switch.
-
+ msg_cancelled: 'You can not use a lighter in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not use a lighter in this region!'
- }
dRegions_Flag_Bucket-Fill:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Bucket-Fill<&4>]"
lore:
- <&5>Who can fill a bucket in a region
event_hooks: player_fill_bucket
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Bucket-Fill
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to fill buckets in this region. Defaults to allow. Takes the -g group switch.
-
+ msg_cancelled: 'You can not fill a bucket in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not fill a bucket in this region!'
- }
dRegions_Flag_Bucket-Empty:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Bucket-Empty<&4>]"
lore:
- <&5>Who can empty a bucket in a region
event_hooks: player_empty_bucket
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Bucket-Empty
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to empty buckets in this region. Defaults to allow. Takes the -g group switch.
+ msg_cancelled: 'You can not empty a bucket in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not empty a bucket in this region!'
- }
-
dRegions_Flag_Hanging-Place:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Hanging-Place<&4>]"
lore:
- <&5>Who can place item frames and paintings
event_hooks: player_place_hanging
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Hanging-Place
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to place item frames and paintings in this region. Defaults to allow. Takes the -g group switch.
-
+ msg_cancelled: 'You can not hang that in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not hang that in this region!'
- }
dRegions_Flag_Hanging-Break:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Hanging-Break<&4>]"
lore:
- <&5>Who can break item frames and paintings
event_hooks: player_break_hanging
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Hanging-Break
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to break item frames and paintings in this region. Defaults to allow. Takes the -g group switch.
-
+ msg_cancelled: 'You can not break that in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not break that in this region!'
- }
dRegions_Flag_Sleep:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Sleep<&4>]"
lore:
- <&5>Who can Sleep
event_hooks: player_enters_bed
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Sleep
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to enter beds in this region. Defaults to allow. Takes the -g group switch.
-
+ msg_cancelled: 'You can not sleep here!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not sleep here!'
- }
dRegions_Flag_Player-Drops:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Drops<&4>]"
lore:
- <&5>Who can drop items
event_hooks: player_drops_item
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Player-Drops
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to drop items from their inventory in this region. Defaults to allow. Takes the -g group switch.
+ msg_cancelled: 'You can not drop items in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not drop items in this region!'
- }
-
dRegions_Flag_Player-Drops-OnDeath:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Drops-OnDeath<&4>]"
lore:
- <&5>Who can drop items when they die
event_hooks: player_dies
event_priority: 10
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Player-Drops-OnDeath
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will drop items when they die in this region. Defaults to allow. Takes the -g group switch.
event-cancelled:
- determine NO_DROPS
dRegions_Flag_Player-KeepItems:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Player-KeepItems<&4>]"
lore:
- <&5>Can players keep items on death
event_hooks: player_dies
event_priority: 5
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Player-KeepItems
flag_takeGroup: true
flag_regionDefault: deny/all
flag_globalDefault: 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.
event-allowed:
- run locally returnItems 'player:%player%' 'def:<def[player].inventory.list_contents.escaped>|<def[player].equipment.escaped>' delay:2t
- determine NO_DROPS_NO_XP
returnItems:
- inventory clear
- run s@msgPrefixed delay:1t 'def:dRegions|<&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_Player-Pickup:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Player-Pickup<&4>]"
lore:
- <&5>Who can pickup items
event_hooks: player_pickup_item
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Player-Pickup
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to pickup items in this region. Defaults to allow. Takes the -g group switch.
+ msg_cancelled: 'You can not pick up items in this region!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not pick up items here!'
- }
-
dRegions_Flag_Potion-Drink:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Potion-Drink<&4>]"
lore:
- <&5>Who can drink potions
event_hooks: player_drink_potion
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Potion-Drink
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to drink potions in this region. Defaults to allow. Takes the -g group switch.
-
+ msg_cancelled: 'You can not drink potions here!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not drink potions here!'
- }
dRegions_Flag_Enderpearl:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Enderpearl<&4>]"
lore:
- <&5>Who can use enderpearls
event_hooks: player_use_enderpearl
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Enderpearl
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to teleport with enderpearls in this region. Defaults to allow. Takes the -g group switch.
+ msg_cancelled: 'You can not use enderpearls here!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not use enderpearls here!'
- }
-
dRegions_Flag_Vehicle-Place:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Vehicle-Place<&4>]"
lore:
- <&5>Who can place vehicles
event_hooks: player_place_vehicle
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Vehicle-Place
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to place vehicles in this region. Defaults to allow. Takes the -g group switch.
-
+ msg_cancelled: 'You can not place vehicles here!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not place vehicles here!'
- }
dRegions_Flag_Vehicle-Destroy:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Vehicle-Destroy<&4>]"
lore:
- <&5>Who can destroy vehicles
event_hooks: player_break_vehicle
event_priority: 0
region_highestOnly: true
- flag_type: state-withGroup
+ flag_type: sg
flag_name: Vehicle-Destroy
flag_takeGroup: true
flag_regionDefault: deny/nonmembers
flag_globalDefault: allow/all
flag_help: State flag controlling whether players will be able to break vehicles in this region. Defaults to allow. Takes the -g group switch.
-
+ msg_cancelled: 'You can not break vehicles here!'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not break vehicles here!'
- }
#
-# END State-withGroup
+# END sg
#---------------------------------------
#
################################################################################
#
-# State-withTargetString-withGroup Flag Scripts
+# stsg Flag Scripts
#
dRegions_Flag_Commands:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Commands<&4>]"
lore:
- <&5>Can players use commands.
event_hooks: player_command
event_priority: 0
region_highestOnly: false
- flag_type: state-withTargetString-withGroup
+ flag_type: stsg
flag_name: Commands
flag_targetList: Commands-List
flag_takeGroup: true
flag_regionDefault: allow/all
flag_globalDefault: allow/all
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.
-
- event-allowed:
- - if <def[setCache].exists> {
+ msg_cancelled: 'You can not use the %1% <&c>command in this region!'
+#
+# END stsg
- - if %sameRegion% {
- - flag %player% 'dRegions.rateLimit.%flag%.%target%:true' d:10s
- }
- - flag %player% 'dRegions.cache.%world%.%thisRegion%.%flag%.%target%:true'
- }
-
- event-cancelled:
- - if <def[setCache].exists> {
- - if %sameRegion% {
- - flag %player% 'dRegions.rateLimit.%flag%.%target%:false' d:10s
- }
- - flag %player% 'dRegions.cache.%world%.%thisRegion%.%flag%.%target%:false'
- }
- - run locally msg delay:1t 'player:%player%' 'def:%target%'
-
- msg:
- - ^if <player.has_flag[dRegions.Message_Cooldown].not> {
- - flag <player> dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed 'def:dRegions|<&c><&o>You can not use the %1% <&c>command in this region!'
- }
-# END State-withTargetString-withGroup
#---------------------------------------
#
################################################################################
#
# Boolean Flag Scripts
#
dRegions_Flag_Notify-Enter:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Notify-Enter<&4>]"
lore:
- <&5>Send notification to marked players
event_hooks: player_entered_dregion
event_priority: 5
- flag_type: boolean
+ flag_type: b
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.
event-allowed:
- foreach <server.list_online_players.filter[permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
- run s@msgPrefixed player:%value% 'def:dRegions|<&5><&o><def[player].name> entered %thisRegion% in %world%'
}
dRegions_Flag_Notify-Exit:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Notify-Exit<&4>]"
lore:
- <&5>Send notification to marked players
event_hooks: player_exited_dregion
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Notify-Exit
flag_takeGroup: false
flag_regionDefault: false
flag_globalDefault: none
flag_help: Boolean flag controlling whether notifications are sent for exiting this region. Set to true or false. Defaults to false.
event-allowed:
- foreach <server.list_online_players.filter[permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
- run s@msgPrefixed player:%value% 'def:dRegions|<&5><&o><def[player].name> exited %thisRegion% in %world%'
}
dRegions_Flag_Ice-Form:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Ice-Form<&4>]"
lore:
- <&5>Can water turn into ice
event_hooks: blockform_ice
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Ice-Form
flag_takeGroup: false
flag_regionDefault: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether ice can form in this region. Set to true or false. Defaults to true.
dRegions_Flag_Lava-Fire:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Lava-Fire<&4>]"
lore:
- <&5>Can lava cause fires
event_hooks: firefrom_lava
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Lava-Fire
flag_takeGroup: false
flag_regionDefault: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether lava can cause fires in this region. Set to true or false. Defaults to true.
dRegions_Flag_Ice-Melt:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Ice-Melt<&4>]"
lore:
- <&5>Can ice melt
event_hooks: blockfade_ice
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Ice-Melt
flag_takeGroup: false
flag_regionDefault: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether ice can melt in this region. Set to true or false. Defaults to true.
dRegions_Flag_Snow-Melt:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Snow-Melt<&4>]"
lore:
- <&5>Can snow melt
event_hooks: blockfade_snow
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Snow-Melt
flag_takeGroup: false
flag_regionDefault: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether snow can melt in this region. Set to true or false. Defaults to true.
dRegions_Flag_Soil-Dry:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Soil-Dry<&4>]"
lore:
- <&5>Can soil dry up
event_hooks: blockfade_soil
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Soil-Dry
flag_takeGroup: false
flag_regionDefault: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether soil can dry in this region. Set to true or false. Defaults to true.
dRegions_Flag_Trample-Crops-Player:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Trample-Crops-Player<&4>]"
lore:
- <&5>Can players trample crops
event_hooks: player_trample_crops
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Trample-Crops-Player
flag_takeGroup: false
flag_regionDefault: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether players can trample crops in this region. Set to true or false. Defaults to true.
dRegions_Flag_Trample-Crops-Entity:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Trample-Crops-Entity<&4>]"
lore:
- <&5>Can entities trample crops
event_hooks: entity_trample_crops
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Trample-Crops-Entity
flag_takeGroup: false
flag_regionDefault: true
flag_globalDefault: true
flag_help: Boolean flag controlling whether entities can trample crops in this region. Set to true or false. Defaults to true.
dRegions_Flag_Mushroom-Spread:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Mushroom-Spread<&4>]"
lore:
- <&5>Can Mushrooms spread
event_hooks: blockspread_mushroom
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Mushroom-Spread
flag_takeGroup: false
flag_regionDefault: 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.
dRegions_Flag_Grass-Spread:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Grass-Spread<&4>]"
lore:
- <&5>Can Grass spread
event_hooks: blockspread_grass
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Grass-Spread
flag_takeGroup: false
flag_regionDefault: 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.
dRegions_Flag_Mycel-Spread:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Mycel-Spread<&4>]"
lore:
- <&5>Can Mycelium spread
event_hooks: blockspread_mycel
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Mycel-Spread
flag_takeGroup: false
flag_regionDefault: 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.
dRegions_Flag_Vines-Spread:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Vine-Growth<&4>]"
lore:
- <&5>Can Vines grow
event_hooks: blockspread_vine
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Vine-Growth
flag_takeGroup: false
flag_regionDefault: 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.
dRegions_Flag_Leaf-Decay:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Leaf-Decay<&4>]"
lore:
- <&5>Can leaves decay
event_hooks: blockfade_leaves
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Leaf-Decay
flag_takeGroup: false
flag_regionDefault: 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.
dRegions_Flag_Falling-Sand:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Falling-Sand<&4>]"
lore:
- <&5>Can sand fall
event_hooks: falling_sand
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Falling-Sand
flag_takeGroup: false
flag_regionDefault: 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.
event-allowed:
- flag <c.entity> 'dRegions.EntityGrief:true' d:5s
event-cancelled:
- flag <c.entity> 'dRegions.EntityGrief:false' d:5s
dRegions_Flag_Falling-Gravel:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Falling-Gravel<&4>]"
lore:
- <&5>Can gravel fall
event_hooks: falling_gravel
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Falling-Gravel
flag_takeGroup: false
flag_regionDefault: 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.
event-allowed:
- flag <c.entity> 'dRegions.EntityGrief:true' d:5s
event-cancelled:
- flag <c.entity> 'dRegions.EntityGrief:false' d:5s
dRegions_Flag_Pistons:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Pistons<&4>]"
lore:
- <&5>Can pistons be activated
event_hooks: piston_extend|piston_retract
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Pistons
flag_takeGroup: false
flag_regionDefault: 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.
dRegions_Flag_Entity-Break-Painting:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Break-Painting<&4>]"
lore:
- <&5>Can Entities break paintings
event_hooks: entity_break_painting
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Entity-Break-Painting
flag_takeGroup: false
flag_regionDefault: 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.
dRegions_Flag_Entity-Break-ItemFrame:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Entity-Break-ItemFrame<&4>]"
lore:
- <&5>Can Entities break item frames
event_hooks: entity_damage_itemframe
event_target: attacker
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Entity-Break-ItemFrame
flag_takeGroup: false
flag_regionDefault: 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.
dRegions_Flag_PVP:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>PVP<&4>]"
lore:
- <&5>Can players damage each other
event_hooks: player_damage_player
event_priority: 5
event_player: attacker
event_target: defender
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: PVP
flag_takeGroup: false
flag_regionDefault: 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.
-
+ msg_cancelled: 'You are in a no PVP zone.'
- event-cancelled:
- - if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- - flag %player% dRegions.Message_Cooldown duration:3s
- - run s@msgPrefixed delay:1t 'player:%player%' 'def:dRegions|<&c><&o>You are in a no PVP zone.'
- }
dRegions_Flag_Potion-Throw:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Potion-Throw<&4>]"
lore:
- <&5>Can potions be thrown in this region
event_hooks: potion_splash|player_throw_potion
event_priority: 5
region_highestOnly: false
- flag_type: boolean
+ flag_type: b
flag_name: Potion-Throw
flag_takeGroup: false
flag_regionDefault: 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.
event-cancelled:
+ # This flag handles players and non-players alike so we need to find out if it is a player before we send a message.
- if <def[player].equals_case_sensitive[null].not||false> {
- if <def[player].has_flag[dRegions.Message_Cooldown].not> {
- flag %player% dRegions.Message_Cooldown duration:3s
- run s@msgPrefixed delay:1t player:%player% 'def:dRegions|<&c><&o>You can not throw potions here!'
}
}
#
# END Boolean
#---------------------------------------
#
################################################################################
#
# String Flag Scripts
#
dRegions_Flag_Greeting:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Greeting<&4>]"
lore:
- <&5>Message on enter region
event_hooks: player_entered_dregion
event_priority: 10
region_highestOnly: true
flag_type: string
string_type: narrate
flag_name: Greeting
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: none
flag_help: Set the greeting message for region entry.
dRegions_Flag_Farewell:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Farewell<&4>]"
lore:
- <&5>Message on exit region
event_hooks: player_exited_dregion
event_priority: 10
region_highestOnly: true
flag_type: string
string_type: narrate
flag_name: Farewell
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: none
flag_help: Set the farewell message for region exit.
#
# END String
#---------------------------------------
#
################################################################################
#
# Custom Flag Scripts
# - Custom flags get a mostly raw event to work with
#
dRegions_Flag_Inventory:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Inventory<&4>]"
lore:
- <&5>Save inventory before going into a region
event_hooks: player_entered_dregion|player_exited_dregion
event_priority: 20
region_highestOnly: true
flag_type: custom
flag_type_customVal: unique|kit
flag_name: Inventory
flag_takeGroup: true
flag_regionDefault: none
flag_globalDefault: none
flag_help: Inventory flag can be set to unique or kit. Unique inventories start empty. Kit inventories use your current inventory.
command_handler:
- if <def[flagValue].is[==].to[kit]> {
- yaml set 'inventories.regions.%region%.entry.kit.equip:<def[player].equipment>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.entry.kit.inv:<def[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:
- if <def[player].gamemode.id> == '0' {
- goto 'end'
}
- define action '<t[%isEnter%]:enter||exit>'
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag%]>'
- if <def[flagObj].equals_case_sensitive[none].not> {
- if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|%player%]> {
- inject locally <def[flagObj].split[/].get[1]>-%action%
}
}
- mark 'end'
kit-enter:
- yaml set 'inventories.regions.%region%.exit.players.<def[player].uuid>.equip:<def[player].equipment>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.exit.players.<def[player].uuid>.inv:<def[player].inventory.list_contents>' 'id:dRegions_%world%_inventories'
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- inventory clear
- inventory set 'd:<def[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@msgPrefixed delay:1t 'def:dRegions|<&7><&o>Your inventory has been updated.'
kit-exit:
- define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<def[player].uuid>.equip]||li@>'
- inventory clear
- inventory set 'd:<def[player].inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<def[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.<def[player].uuid>:!' 'id:dRegions_%world%_inventories'
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- run s@msgPrefixed delay:1t 'def:dRegions|<&7><&o>Your inventory has been updated.'
unique-enter:
- yaml set 'inventories.regions.%region%.exit.players.<def[player].uuid>.equip:<def[player].equipment>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.exit.players.<def[player].uuid>.inv:<def[player].inventory.list_contents>' 'id:dRegions_%world%_inventories'
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- inventory clear
- inventory set 'd:<def[player].inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.players.<def[player].uuid>.inv]||li@>'
- define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.players.<def[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@msgPrefixed delay:1t 'def:dRegions|<&7><&o>Your inventory has been updated.'
unique-exit:
- yaml set 'inventories.regions.%region%.entry.players.<def[player].uuid>.equip:<def[player].equipment>' 'id:dRegions_%world%_inventories'
- yaml set 'inventories.regions.%region%.entry.players.<def[player].uuid>.inv:<def[player].inventory.list_contents>' 'id:dRegions_%world%_inventories'
- define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<def[player].uuid>.equip]||li@>'
- inventory clear
- inventory set 'd:<def[player].inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<def[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.<def[player].uuid>:!' 'id:dRegions_%world%_inventories'
- yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
- run s@msgPrefixed delay:1t 'def:dRegions|<&7><&o>Your inventory has been updated.'
dRegions_Flag_Gamemode:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Gamemode<&4>]"
lore:
- <&5>Change gamemode inside a region
event_hooks: player_entered_dregion|player_exited_dregion
event_priority: 10
region_highestOnly: true
flag_type: custom
flag_type_customVal: creative|survival|adventure|spectator
flag_name: Gamemode
flag_takeGroup: true
flag_regionDefault: none
flag_globalDefault: none
flag_help: Gamemode flag can be set to creative, survival, adventure, or spectator
event:
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag%]>'
- if <def[flagObj].starts_with[none].not> && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|%player%]> {
- if %isEnter% {
- define gm '<def[flagObj].split[/].get[1]>'
- flag %player% 'dRegions.%world%.%region%.PreviousGamemode:<def[player].gamemode>'
- if %gm% != <def[player].gamemode> {
- adjust %player% 'gamemode:%gm%'
- run s@msgPrefixed delay:1t 'def:dRegions|<&7><&o>Your gamemode has been updated.'
}
}
else {
- if <def[player].flag[dRegions.%world%.%region%.PreviousGamemode]||null> != <def[player].gamemode> {
- adjust %player% 'gamemode:<def[player].flag[dRegions.%world%.%region%.PreviousGamemode]||survival>'
- run s@msgPrefixed delay:1t 'def:dRegions|<&7><&o>Your gamemode has been updated.'
}
- flag %player% 'dRegions.%world%.%region%.PreviousGamemode:!'
}
}
dRegions_Flag_Weather-Lock:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Weather-Lock<&4>]"
lore:
- <&5>Set the weather
event_hooks: player_entered_dregion|player_exited_dregion
event_priority: 30
region_highestOnly: true
flag_type: custom
flag_type_customVal: clear|downfall
flag_name: Weather-Lock
flag_takeGroup: true
flag_regionDefault: none
flag_globalDefault: none
flag_help: Control what players see the weather as. Can be set to clear or downfall. Takes the -g group switch.
event:
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag%]>'
- if <def[flagObj].starts_with[none].not> && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|%player%]> {
- if '%isEnter%' {
- adjust %player% 'weather:<def[flagObj].split[/].get[1]>'
}
else {
- adjust %player% 'reset_weather'
}
}
dRegions_Flag_Spawn:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Spawn<&4>]"
lore:
- <&5>Region spawn point.
event_hooks: player_dies
event_priority: 0
region_highestOnly: false
flag_type: location
flag_name: Spawn
flag_takeGroup: true
flag_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- if !<player.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 %orderedRegions% {
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
- if <def[flagObj].starts_with[none].not> && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%value%|%world%|%player%]> {
- flag <player> 'dRegions.Respawn:<def[flagObj].split[/].get[1].as_location>'
- foreach stop
}
}
#
# END Custom
#---------------------------------------
#
################################################################################
#
# Number Flag Scripts
#
dRegions_Flag_Time-Lock:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Time-Lock<&4>]"
lore:
- <&5>Set the Time
event_hooks: player_entered_dregion|player_exited_dregion
event_priority: 30
region_highestOnly: true
flag_type: number
flag_name: Time-Lock
flag_takeGroup: true
flag_regionDefault: none
flag_globalDefault: none
flag_help: Control what players see the time as. Valid range is 0-23999. Use + or - to adjust the time relative to the current world time. Takes the -g group switch.
command_handler:
- if <def[flagValue].starts_with[+]> || <def[flagValue].starts_with[-]> {
- define d '<def[flagValue].replace[regex:[0-9]]>'
- define time '<def[flagValue].after[%d%]>'
}
else {
- define time '%flagValue%'
}
- if %time% !matches number || %time% < 0 || %time% > 23999 {
- run s@msgPrefixed 'def:dRegions|<&c>Valid time range is 0 - 23999!'
- queue clear
}
event:
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag%]>'
- if <def[flagObj].starts_with[none].not> && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|%player%]> {
- define flagValue '<def[flagObj].split[/].get[1]>'
- define d '<def[flagValue].replace[regex:[0-9]]>'
- define time '<def[flagValue].after[%d%]>'
- define time '<t[<def[d].is[==].to[].not>]:<def[player].world.time.add[<def[flagObj].split[/].get[1].replace[+]||0>]>||%time%>'
- adjust %player% '<t[%isEnter%]:freeze_time<&co>%time%||reset_time>'
}
dRegions_Flag_Heal-Amount:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Heal-Amount<&4>]"
lore:
- <&5>The amount to heal or harm.
event_hooks: player_entered_dregion
event_priority: 30
region_highestOnly: true
flag_type: number
flag_name: Heal-Amount
flag_takeGroup: true
flag_regionDefault: none
flag_globalDefault: none
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.
event:
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-amount]>'
- if <def[flagObj].starts_with[none].not> && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|%player%]> {
- if <queue.exists[dRegions_Heal_<def[player].name>]> {
- queue 'q@dRegions_Heal_<def[player].name>' clear
}
- run locally healTask delay:1t 'player:%player%' 'def:%world%|%region%|<def[flagObj].split[/].get[1]>' id:dRegions_Heal_<def[player].name>
}
healTask:
- define player '<player>'
- define world '%1%'
- define region '%2%'
- define healAmount '%3%'
- define healDelay '<proc[dRegions_GetInheritedFlag].context[%1%|%2%|heal-delay]>'
- define healDelay '<el@1.max[<t[<def[healDelay].equals_case_sensitive[none]>]:5||%healDelay%>].as_int.as_duration>'
- define healMax '<proc[dRegions_GetInheritedFlag].context[%1%|%2%|heal-max]>'
- define healMax '<def[player].health.max.min[<t[<def[healMax].equals_case_sensitive[none]>]:20||%healMax%>]>'
- define healMin '<proc[dRegions_GetInheritedFlag].context[%1%|%2%|heal-min]>'
- define healMin '<t[<def[healMin].equals_case_sensitive[none]>]:0||%healMin%>'
- while '<def[player].is_online>':
- if <def[player].world.name.equals_case_sensitive[%1%].not> {
- while stop
}
- if <def[player].gamemode.id.equals_case_sensitive[1]> {
- wait 1s
- while next
}
- define regionPri 'li@'
- foreach <def[player].location.cuboids.filter[notable_name.starts_with[dRegions_]].parse[after[cu@dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- if <def[regionPri].alphanumeric.reverse.parse[after[/]].get[1].equals_case_sensitive[%2%].not> {
- while stop
}
# Instant heal/harm setting
- if %healDelay% == 0 {
- if %healAmount% MORE 0 {
- if <def[player].health> LESS %healMax% {
- define newHealth '<def[player].health.add[%healMax%]>'
- adjust %player% 'health:<tern[<def[newHealth].is[MORE].than[%healMax%]>]:%healMax%||%newHealth%>'
}
}
else {
- if <def[player].health> MORE %healMin% {
- animate %player% animation:hurt
- define newHealth '<def[player].health.add[%healAmount%]>'
- adjust %player% 'health:<tern[<def[newHealth].is[LESS].than[%healMin%]>]:%healMin%||%newHealth%>'
}
}
- wait 20t
- while next
}
# Normal delayed setting
- if %healAmount% MORE 0 {
- if <def[player].health> LESS %healMax% {
- define newHealth '<def[player].health.add[%healAmount%].min[<player.health.max>]>'
- adjust %player% 'health:<tern[<def[newHealth].is[MORE].than[%healMax%]>]:%healMax%||%newHealth%>'
}
}
else {
- if <def[player].health> MORE %healMin% {
- animate %player% animation:hurt
- define newHealth '<def[player].health.add[%healAmount%].min[0]>'
- adjust %player% 'health:<tern[<def[newHealth].is[LESS].than[%healMin%]>]:%healMin%||%newHealth%>'
}
}
- wait %healDelay%
dRegions_Flag_Heal-Delay:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Heal-Delay<&4>]"
lore:
- <&5>The duration between heal intervals
event_hooks: none
event_priority: 0
region_highestOnly: true
flag_type: number
flag_name: Heal-Delay
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: none
flag_help: Set the time in seconds between heal intervals. Defaults to 5 seconds.
command_handler:
- if <def[flagValue].is[LESS].than[0]> {
- run s@msgPrefixed 'def:dRegions|<&c>Can not specify negative time!'
- queue clear
}
dRegions_Flag_Heal-Max:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Heal-Max<&4>]"
lore:
- <&5>Max health for heal flag.
event_hooks: none
event_priority: 0
region_highestOnly: true
flag_type: number
flag_name: Heal-Max
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: none
flag_help: Set the max health that the heal flag will heal a player to. Defaults to 20.
command_handler:
- if !<def[flagValue].is[MORE].than[0]> {
- run s@msgPrefixed 'def:dRegions|<&c>Must be a value greater than 0!'
- queue clear
}
dRegions_Flag_Heal-Min:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Heal-Min<&4>]"
lore:
- <&5>Minimum health for heal flag
event_hooks: none
event_priority: 0
region_highestOnly: true
flag_type: number
flag_name: Heal-Min
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: none
flag_help: Set the min health that the heal flag will heal a player to. Defaults to 0.
command_handler:
- if <def[flagValue].is[LESS].than[0]> {
- run s@msgPrefixed 'def:dRegions|<&c>Can not set to a negative number!'
- queue clear
}
dRegions_Flag_Feed-Amount:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Feed-Amount<&4>]"
lore:
- <&5>The amount to feed or starve.
event_hooks: player_entered_dregion
event_priority: 30
region_highestOnly: true
flag_type: number
flag_name: Feed-Amount
flag_takeGroup: true
flag_regionDefault: none
flag_globalDefault: none
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.
event:
- define region '<def[orderedRegions].get[1]>'
- define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-amount]>'
- if <def[flagObj].starts_with[none].not> && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|%player%]> {
- if <queue.exists[dRegions_Feed_<def[player].name>]> {
- queue 'q@dRegions_Feed_<def[player].name>' clear
}
- run locally feedTask delay:1t 'player:%player%' 'def:%world%|%region%|<def[flagObj].split[/].get[1]>' id:dRegions_Feed_<def[player].name>
}
feedTask:
- define player '<player>'
- define world '%1%'
- define region '%2%'
- define feedAmount '%3%'
- define feedDelay '<proc[dRegions_GetInheritedFlag].context[%1%|%2%|feed-delay]>'
- define feedDelay '<t[<def[feedDelay].equals_case_sensitive[none]>]:5||%feedDelay%>'
- define feedMax '<proc[dRegions_GetInheritedFlag].context[%1%|%2%|feed-max]>'
- define feedMax '<t[<def[feedMax].equals_case_sensitive[none]>]:20||%feedMax%>'
- define feedMin '<proc[dRegions_GetInheritedFlag].context[%1%|%2%|feed-min]>'
- define feedMin '<t[<def[feedMin].equals_case_sensitive[none]>]:0||%feedMin%>'
- while '<def[player].is_online>':
- if <def[player].world.name.equals_case_sensitive[%1%].not> {
- while stop
}
- if <def[player].gamemode.id.equals_case_sensitive[1]> {
- wait 1s
- while next
}
- define regionPri 'li@'
- foreach <def[player].location.cuboids.filter[notable_name.starts_with[dRegions_]].parse[after[cu@dregions_%world%_]].include[__global__]> {
- define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
}
- if <def[regionPri].alphanumeric.reverse.parse[after[/]].get[1].equals_case_sensitive[%2%].not> {
- while stop
}
# Instant feed/starve setting
- if %feedDelay% == 0 {
- if %feedAmount% MORE 0 {
- if <def[player].food_level> LESS %feedMax% {
- define newFood '<def[player].food_level.add[%feedMax%]>'
- adjust %player% 'food_level:<tern[<def[newFood].is[MORE].than[%feedMax%]>]:%feedMax%||%newFood%>'
- adjust %player% 'saturation:<def[player].food_level>'
}
}
else {
- if <def[player].food_level> MORE %feedMin% {
- animate %player% animation:hurt
- define newFood '<def[player].food_level.add[%feedAmount%]>'
- adjust %player% 'food_level:<tern[<def[newFood].is[LESS].than[%feedMin%]>]:%feedMin%||%newFood%>'
- adjust %player% 'saturation:<def[player].food_level>'
}
}
- wait 20t
- while next
}
# Normal delayed setting
- if %feedAmount% MORE 0 {
- if <def[player].food_level> LESS %feedMax% {
- define newFood '<def[player].food_level.add[%feedAmount%]>'
- adjust %player% 'food_level:<tern[<def[newFood].is[MORE].than[%feedMax%]>]:%feedMax%||%newFood%>'
- adjust %player% 'saturation:<def[player].food_level>'
}
}
else {
- if <def[player].food_level> MORE %feedMin% {
- animate %player% animation:hurt
- define newFood '<def[player].food_level.add[%feedAmount%]>'
- adjust %player% 'food_level:<tern[<def[newFood].is[LESS].than[%feedMin%]>]:%feedMin%||%newFood%>'
- adjust %player% 'saturation:<def[player].food_level>'
}
}
- wait %feedDelay%
dRegions_Flag_Feed-Delay:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Feed-Delay<&4>]"
lore:
- <&5>The duration between feed intervals
event_hooks: none
event_priority: 0
region_highestOnly: true
flag_type: number
flag_name: Feed-Delay
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: none
flag_help: Set the time in seconds between feed intervals. Defaults to 5 seconds.
command_handler:
- if <def[flagValue].is[LESS].than[0]> {
- run s@msgPrefixed 'def:dRegions|<&c>Can not specify negative time!'
- queue clear
}
dRegions_Flag_Feed-Max:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Feed-Max<&4>]"
lore:
- <&5>Max food level
event_hooks: none
event_priority: 0
region_highestOnly: true
flag_type: number
flag_name: Feed-Max
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: none
flag_help: Set the max food level that the feed-amount flag will bring a player to. Defaults to 20.
command_handler:
- if !<def[flagValue].is[MORE].than[0]> {
- run s@msgPrefixed 'def:dRegions|<&c>Must be a value greater than 0!'
- queue clear
}
dRegions_Flag_Feed-Min:
type: item
debug: false
material: i@paper
display name: "<&4>[<&6>Feed-Min<&4>]"
lore:
- <&5>Minimum food level
event_hooks: none
event_priority: 0
region_highestOnly: true
flag_type: number
flag_name: Feed-Min
flag_takeGroup: false
flag_regionDefault: none
flag_globalDefault: none
flag_help: Set the min food level that the feed-amount flag will bring a player to. Defaults to 0.
command_handler:
- if <def[flagValue].is[LESS].than[0]> {
- run s@msgPrefixed 'def:dRegions|<&c>Can not set to a negative number!'
- queue clear
}
#
# END Number
#---------------------------------------
#
################################################################################
#
# List Flag Scripts
#
dRegions_Flag_Mob-TargetList:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Mob-Damagelist:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Mob-SpawnList:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_EVE-Moblist:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Mob-Attack-Moblist:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_PVE-Moblist:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Entity-Interactlist:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Entity-ExplodeList:
type: item
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_regionDefault: none
flag_globalDefault: none
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
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Entity-GriefList:
type: item
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_regionDefault: none
flag_globalDefault: none
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
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Entity-Drops-OnDeathList:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Fire-SpreadBlocks:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Fire-DestroyBlocks:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Lightning-StrikesBlocks:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Water-SpreadBlocks:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Lava-SpreadBlocks:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Snow-FallBlocks:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Block-PlaceList:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Block-BreakList:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Chest-Access-Blocks:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Door-Access-Doors:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Use-Switches-List:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Use-Utilities-Blocks:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Player-Damage-Types:
type: item
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_regionDefault: none
flag_globalDefault: none
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.
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
dRegions_Flag_Commands-List:
type: item
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_regionDefault: none
flag_globalDefault: none
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!
command_handler:
- inject s@dRegions_Flags_CommandProcessors p:command_stringList
# END List
#---------------------------------------
#
-################################################################################
+#################################################################################
-#
# THIS Flag Scripts
#
# END THIS
#---------------------------------------
#
################################################################################
#
#
#
################################################################################
#
# dRegions Command Script Container
#
# This script covers all dRegions commands
#
# I haven't examined this in great detail since dRegions 0.2x. It's probably
# due for some revisions
#
#--------------------------------------
#
# 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:
- dregions.reload
restart:
usage: '/drg restart'
permissions:
- dregions.restart
define:
usage: '/drg define [ID] (g:group) (player)'
permissions:
- dregions.define
redefine:
usage: '/drg redefine [ID]'
permissions:
- dregions.redefine
- dregions.redefine.own.*
- dregions.redefine.own.%region%
- dregions.redefine.member.*
- dregions.redefine.member.%region%
claim:
usage: '/drg claim [ID]'
permissions: []
select:
usage: '/drg select [ID] -w world'
permissions: []
info:
usage: '/drg info [ID] -w world'
permissions:
- dregions.info
- dregions.info.own.*
- dregions.info.own.%region%
- dregions.info.member.*
- dregions.info.member.%region%
addowner:
usage: '/drg addowner [ID] g:group player -w world'
permissions:
- dregions.addowner
- dregions.addowner.own.*
- dregions.addowner.own.%region%
- dregions.addowner.member.*
- dregions.addowner.member.%region%
removeowner:
usage: '/drg removeowner [ID] g:group player -w world'
permissions:
- dregions.removeowner
- dregions.removeowner.own.*
- dregions.removeowner.own.%region%
- dregions.removeowner.member.*
- dregions.removeowner.member.%region%
addmember:
usage: '/drg addmember [ID] g:group player -w world'
permissions:
- dregions.addmember
- dregions.addmember.own.*
- dregions.addmember.own.%region%
- dregions.addmember.member.*
- dregions.addmember.member.%region%
removemember:
usage: '/drg removemember [ID] g:group player -w world'
permissions:
- dregions.removemember
- dregions.removemember.own.*
- dregions.removemember.own.%region%
- dregions.removemember.member.*
- dregions.removemember.member.%region%
list:
usage: '/drg list (page<&ns>) -h -r region -w world -p player'
permissions:
- dregions.list
- dregions.list.own.*
- dregions.list.own.%region%
- dregions.list.member.*
- dregions.list.member.%region%
flag:
usage: '/drg flag [ID] [flag] [value] -g group -w world'
permissions:
- dregions.flags.*
- dregions.flags.<def[flag]>
- dregions.flag
- dregions.flag.flags.*
- dregions.flag.flags.<def[flag]>
- dregions.flag.own.*
- dregions.flag.own.<def[region]>
- dregions.flag.member.*
- dregions.flag.member.<def[region]>
setpriority:
usage: '/drg setpriority [ID] [<&ns>]'
permissions:
- dregions.setpriority
- dregions.setpriority.own.*
- dregions.setpriority.own.%region%
- dregions.setpriority.member.*
- dregions.setpriority.member.%region%
setparent:
usage: '/drg setparent [ID] [parent]'
permissions:
- dregions.setparent
- dregions.setparent.own.*
- dregions.setparent.own.%region%
- dregions.setparent.member.*
- dregions.setparent.member.%region%
teleport:
usage: '/drg teleport [ID] -w world'
permissions:
- dregions.teleport
- dregions.teleport.own.*
- dregions.teleport.own.%region%
- dregions.teleport.member.*
- dregions.teleport.member.%region%
remove:
usage: '/drg remove [ID] -w world'
permissions:
- dregions.remove
- dregions.remove.own.*
- dregions.remove.own.%region%
- dregions.remove.member.*
- dregions.remove.member.%region%
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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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[%member%].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.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.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[%member%].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.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.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].as_list||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].as_list||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.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.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
# /drg teleport [ID] -w world
- define result 'li@'
tab_remove:
# /drg remove [ID] -w world
- if <player.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.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@msgPrefixed delay:1t 'def:dRegions|<parse:<script.yaml_key[commandArgs.%arg%.usage]||No help for you!>>'
- queue clear
}
- if <player.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.permission[dRegions.reload]||<player.is_op||<context.server||false>>> {
- inject locally help
- queue clear
}
- inject s@dRegions p:reloadYaml instantly
# - run s@msgPrefixed delay:1t 'def:dRegions|<&7><&o>System files loaded!'
restart:
- if !<player.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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists]> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is already a region by this name!'
- queue clear
}
# Check for overlapping regions
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].separated_by[/].replace[cu@]>|%world%|<player>]> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>You can not redefine global regions!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>You are not an owner of this region!'
- queue clear
}
}
# Check for overlapping regions
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].separated_by[/].replace[cu@]>|%world%|<player>]> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>You already have <def[playerGlobalRegions].size> total regions!'
- if !<player.permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>You already have <def[playerWorldRegions].size> regions in this world!'
- if !<player.permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>Your selection exceeds the global limit!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&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.permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>Your selection exceeds the world limit!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&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.permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>You may only claim regions within land you own'
- if !<player.permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists]> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>You can not redefine global regions!'
- queue clear
}
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Region already exists!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&7>You must want to update the region'
- define update ''
}
# Check for overlapping regions
# The perm check here is redundant
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].separated_by[/].replace[cu@]>|%world%|<player>]> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Region selection contains unowned regions!'
- if !<player.permission[dRegions.admin]||<player.is_op||false>> {
- queue clear
}
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&f><&o>%name%<&7><&o> updated to selection'
}
else {
- define ownerPlayers 'li@<player.uuid>'
- inject s@dRegions p:createRegionEntry instantly
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>You can not select global regions!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region named %name%!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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"
+
+ - define title '<proc[msgCommand].context[<&6>dRegions|drg help|<&a>Go back to main help]>'
+ - define subTitle '<&e>Region Info'
+ - define command 'drg info %name%'
+ - define entries 'li@<&7>Region<&co> <&e><proc[msgTrim].context[15|%name%]> <&7>World<&co> <&e><proc[msgTrim].context[15|%world%]>'
+ - define entries '<def[entries].include[<&7>Type<&co> <&f>%type% <&7>Volume<&co> <&8><&lb><&f><&o>%size%<&8><&rb>]>'
+ - define entries '<def[entries].include[<&7>Area<&co> <&8><&lb><&f><&o><def[pos1].split[,].remove[4].separated_by[,]> <&f><&o><def[pos2].split[,].remove[4].separated_by[,]><&8><&rb>]>'
+ - define entries '<def[entries].include[<&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> {
+ - define entries '<def[entries].include[<&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 entries '<def[entries].include[<&7>Owners<&co> <&f><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> {
+ - if <def[memberPlayers].is_empty||true> && <def[memberGroups].is_empty||true> {
+ - define entries '<def[entries].include[<&7>Members<&co> <&c>none]>'
- - 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 entries '<def[entries].include[<&7>Members<&co> <&f><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"
+ - define entries '<def[entries].include[<&7>Flags<&co> <&c>none]>'
}
else {
- - narrate "<&5><el@val[|].pad_right[3]><&7>Flags<&co>"
+ - define entries '<def[entries].include[<&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 flagVal '<def[value].after[/].strip_color>'
+ - define entries '<def[entries].include[<&e.pad_left[3]>%flag%<&co> <&f><parse:%flagVal%>]>'
- - 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
+
+ - run s@msgBoxed 'def:dRegions|%title%|%subTitle%|%command%|%page%|52|14|<def[entries].separated_by[|]>'
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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>Must specify at least one owner'
- queue clear
}
- foreach %owners% {
- if <def[value].starts_with[g;]||false> {
- define group '<def[value].replace[g;]>'
- if <server.list_permission_groups> !contains %group% {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>%group% is not a valid group'
- foreach next
}
- define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.groups]||li@>'
- if <def[groups].contains[%group%]||false> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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'
- flag <def[value].as_player> 'dRegions.cache.%world%.%name%:!'
}
}
- if <def[pass].exists||false> {
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>Must specify at least one owner'
- queue clear
}
- foreach %owners% {
- if <def[value].starts_with[g;]||false> {
- define group '<def[value].replace[g;]>'
- if <server.list_permission_groups> !contains %group% {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>%group% is not a valid group'
- foreach next
}
- define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.groups]||li@>'
- if <def[groups].contains[%group%].not||true> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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'
- flag <def[value].as_player> 'dRegions.cache.%world%.%name%:!'
}
}
- if <def[pass].exists||false> {
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@msgPrefixed delay:1t 'def:dRegions|<&f><&o>%name%<&7><&o> owners updated'
}
else {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>Must specify at least one member'
- queue clear
}
- foreach %members% {
- if <def[value].starts_with[g;]||false> {
- define group '<def[value].replace[g;]>'
- if <server.list_permission_groups> !contains %group% {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>%group% is not a valid group'
- foreach next
}
- define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.members.groups]||li@>'
- if <def[groups].contains[%group%]||false> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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'
- flag <def[value].as_player> 'dRegions.cache.%world%.%name%:!'
}
}
- if <def[pass].exists||false> {
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@msgPrefixed delay:1t 'def:dRegions|<&f><&o>%name%<&7><&o> members updated'
}
else {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>Must specify at least one member'
- queue clear
}
- foreach %members% {
- if <def[value].starts_with[g;]||false> {
- define group '<def[value].replace[g;]>'
- if <server.list_permission_groups> !contains %group% {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>%group% is not a valid group'
- foreach next
}
- define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.members.groups]||li@>'
- if <def[groups].contains[%group%].not||true> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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'
- flag <def[value].as_player> 'dRegions.cache.%world%.%name%:!'
}
}
- if <def[pass].exists||false> {
- yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
- run s@msgPrefixed delay:1t 'def:dRegions|<&f><&o>%name%<&7><&o> members updated'
}
else {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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.permission[dregions.admin]||<player.is_op||false>> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>You are not an owner of this region!'
- queue clear
}
}
}
else {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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%_]].separated_by[,]>'
- 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 entries 'li@'
+ - foreach '<def[regions]>':
+ - define color '<t[<def[value].split[.].get[3].is[==].to[owner]>]:&6||<t[<def[value].split[.].get[3].is[==].to[member]>]:&e||&f>>'
+ - define entry '<def[loop_index].pad_left[3].with[<&sp>]><&dot.pad_right[2].with[<&sp>]> <proc[msgCommand].context[<%color%><def[value].split[.].get[2]>|drg info <def[value].split[.].get[2]>|<&d>Click for region info]>'
+ - define entries '<def[entries].include[%entry%]>'
+ - run s@msgBoxed 'def:dRegions|<proc[msgCommand].context[<&6>dRegions|drg help|<&a>Go back to main help]>|<&e>Region List|drg list|%page%|52|10|<def[entries].separated_by[|]>'
- }
- - 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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>You are not an owner of this region!'
- queue clear
}
}
}
else {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>You must specify a valid region flag!'
- queue clear
}
}
else {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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'
- 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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if player owns parent
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%parent%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&f><&o>%name%<&7><&o> set parent to <&f><&o>%parent%'
teleport:
# /drg teleport [ID] -w world
- narrate "Stub"
- inject locally prerun instantly
# Check if region exists
- define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
- if <def[exists]> == orphan {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if !%exists% {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||false> && !<player.is_op> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>You are not an owner of this region!'
- queue clear
}
}
# Check for teleport perms
- if !<player.permission[dregions.teleport]||false> && !<player.permission[dregions.teleport.own]||false> && !<player.permission[dregions.teleport.own.%name%]||false> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>You do not have permission!'
- queue clear
}
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@msgPrefixed delay:1t 'def:dRegions|<&c>There is an orphaned region by this name!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Please notify an admin!'
- queue clear
}
else if <def[exists].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>There is no region by this name!'
- queue clear
}
# Don't remove the __global__ region
- if <def[name].is[==].to[__global__]> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>You can not remove the __global__ region!'
- queue clear
}
# Check if is owner
- if !<player.permission[dregions.admin]||<player.is_op||false>> {
- if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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.permission[dRegions.%command%]||false> && !<player.is_op> {
- 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@msgPrefixed delay:1t 'def:dRegions|<&c>Invalid world specfied!'
- run s@msgPrefixed delay:1t 'def:dRegions|<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@msgPrefixed delay:1t 'def:dRegions|<&c>You must select a cuboid type region!'
- run s@msgPrefixed delay:1t 'def:dRegions|<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@msgPrefixed delay:1t 'def:dRegions|<&c>No region selected!'
- run s@msgPrefixed delay:1t 'def:dRegions|<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@msgPrefixed delay:1t 'def:dRegions|<&c>Selected region not within specified world!'
- run s@msgPrefixed delay:1t 'def:dRegions|<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%_]].separated_by[,]>'
- 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@msgPrefixed delay:1t 'def:dRegions|<&c><&o>There are multiple regions at this location!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&7><&o>Getting highest priority region info.'
}
}
}
else {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>You must specify a region ID!'
- run s@msgPrefixed delay:1t 'def:dRegions|<script.yaml_key[commandArgs.%command%.usage]>'
- queue stop
}
}
- if '<def[name].matches[^[a-z0-9-_]+$].not>' {
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>Region ID may only contain letters, numbers,'
- run s@msgPrefixed delay:1t 'def:dRegions|<&c>hyphen, and underscore!'
- run s@msgPrefixed delay:1t 'def:dRegions|<script.yaml_key[commandArgs.%command%.usage]>'
- queue stop
}
+ - define page "<t[<c.args.filter[is[matches].to[number]].is_empty.not>]:<c.args.filter[is[matches].to[number]].get[1]>||1>"
# - 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]>>'
+ - 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]>>'
+ - 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]>>'
+ - 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
+ - define size '<proc[selectionSize].context[%pos1%|%pos2%]>'
}
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@msgPrefixed delay:1t 'def:dRegions|<&c>This region is misconfigured!'
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@dRegions_Author_Anthony.json><&chr[007D]>'<&chr[007D]>"
# - define spacer "text<&co>' '"
# - define prefix "text<&co>'<&5>| <&f>Authors<&co> '"
- if <player.is_player||false> {
# JSON is broken in denizen. Just narrate for now.
- narrate "<&5>| <&f>Authors<&co> <&7>|Anthony|"
# - 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.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><parse:<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
#
#--------------------------------------
#
# Used to process input for some flags
#
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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c><&o>%value% is not a valid <s@dRegions_Flag_%Flag%.yaml_key[command_entryType]>!'
}
}
- if <def[entries].is_empty||true> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>Cleared %flag% list for region %region%'
- queue clear
}
}
- if <def[string].length.is[==].to[0]||true> {
- run s@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&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@msgPrefixed delay:1t 'def:dRegions|<&c>Cleared %flag% list for region %region%'
- queue clear
}
- define flagValue '<def[flagValue].replace[|].with[ ; ].replace[li@]>'
################################################################################
#
# 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 not a %type%"
# }
#
dRegion_FlagTypeMatch:
# Used to check if the value supplied when setting a flag is valid for the flag type.
type: procedure
- speed: 0
debug: false
definitions: YourValue|Flag
script:
- - announce '<s@dRegions_Flag_%Flag%.yaml_key[flag_type]||null>'
- choose '<s@dRegions_Flag_%Flag%.yaml_key[flag_type]||null>':
- case 'number':
- determine '<def[YourValue].is[MATCHES].to[number]>'
- case 'decimal':
- determine '<def[YourValue].is[MATCHES].to[number]>.and[<def[YourValue].as_int.is[==].to[%YourValue%]>]>'
- - case 'boolean':
+ - case 'b':
- determine '<def[YourValue].is[MATCHES].to[boolean]>'
- case 'location':
- determine '<def[YourValue].as_location.world.is[!=].to[null]||false>'
- - case 'state-withTarget-withGroup':
+ - case 'stg':
- determine '<li@allow|deny|none.contains[%YourValue%]||false>'
- - case 'state-withTarget':
+ - case 'st':
- determine '<li@allow|deny|none.contains[%YourValue%]||false>'
- - case 'state-withGroup':
+ - case 'sg':
- determine '<li@allow|deny|none.contains[%YourValue%]||false>'
- - case 'state-withTargetString-withGroup':
+ - case 'stsg':
- determine '<li@allow|deny|none.contains[%YourValue%]||false>'
- case 'group':
- determine '<li@members|nonmembers|owners|nonowners|all.as_list.contains[%YourValue%]||false>'
- case 'list':
- determine '<def[YourValue].split[ ].get[1].contains_any_text[-a|-r]||false>'
- case 'custom':
- determine '<s@dRegions_Flag_%flag%.yaml_key[flag_type_customVal].as_list.contains[%YourValue%]||false>'
- case 'string':
- determine '<def[YourValue].is[!=].to[null]||false>'
- default:
- determine 'false'
#
# END dRegion Command System
#---------------------------------------
#
#################################################################################
#
# dRegions WorldGuard Importer
#
# Import WorldGuard regions to dRegions in one fell swoop.
# Also covers popular WG extensions like WorldGuard Custom Flags and WorldRegions
#
#--------------------------------------
dRegions_WG_Importer:
type: task
debug: false
speed: 0
script:
- ^announce "<&b>dRegions<&co><&3> Starting WorldGuard region import..." to_console
- ^inject locally loadYaml
- ^foreach %WG_Import_Worlds% {
- define world '%value%'
- announce "<&b>dRegions<&co><&3> Importing %world% region files..." to_console
- foreach <yaml[dRegions_WGImport_%world%].list_keys[regions]||li@> {
- define region '%value%'
- announce "<&b>dRegions<&co><&3> Importing %region%..." to_console
- inject locally importRegion instantly
}
- yaml 'savefile:dRegions/worlds/<def[world].to_lowercase>/import.yml' 'id:dRegions_%world%_import'
}
- ^inject locally unloadYaml
- ^announce "<&b>dRegions<&co><&3> WorldGuard region import complete!" to_console
unloadYaml:
- yaml unload 'id:dRegions_WGImport_File'
- foreach %WG_Import_Worlds% {
- yaml unload 'id:dRegions_WGImport_%value%'
- yaml unload 'id:dRegions_%value%_import'
}
loadYaml:
- yaml fix_formatting 'load:<script.relative_filename>' 'id:dRegions_WGImport_File'
- announce "<&b>dRegions<&co><&3> Loading WorldGuard region files..." to_console
- define WG_Import_Worlds 'li@'
- foreach <server.list_worlds.parse[name]> {
- define world '%value%'
- if <server.has_file[../WorldGuard/worlds/%world%/regions.yml]||false> {
- define pass ''
- define WG_Import_Worlds '<def[WG_Import_Worlds].include[%world%]>'
- yaml fix_formatting 'load:../WorldGuard/worlds/%world%/regions.yml' 'id:dRegions_WGImport_%world%'
- if !<server.has_file[dRegions/worlds/%world%/import.yml]||false> {
- yaml create 'id:dRegions_%world%_import'
}
- if !<yaml.list.contains[dRegions_%world%_import]> {
- yaml 'load:dRegions/worlds/%world%/import.yml' 'id:dRegions_%world%_import'
}
}
else {
- announce "<&b>dRegions<&co><&c> /WorldGuard/worlds/%world%/regions.yml does not exist!" to_console
}
}
- if <def[pass].exists> {
- announce "<&b>dRegions<&co><&3> WorldGuard region files loaded!" to_console
}
importRegion:
# Set the region type and coordinates
- define type '<yaml[dRegions_WGImport_%world%].read[regions.%region%.type]>'
- yaml set 'regions.%region%.type:%type%' 'id:dRegions_%world%_import'
- if %type% == cuboid {
- define min '<yaml[dRegions_WGImport_%world%].read[regions.%region%.min.x]>,<yaml[dRegions_WGImport_%world%].read[regions.%region%.min.y]>,<yaml[dRegions_WGImport_%world%].read[regions.%region%.min.z]>,%world%'
- define max '<yaml[dRegions_WGImport_%world%].read[regions.%region%.max.x]>,<yaml[dRegions_WGImport_%world%].read[regions.%region%.max.y]>,<yaml[dRegions_WGImport_%world%].read[regions.%region%.max.z]>,%world%'
- yaml set 'regions.%region%.min:<el@val[<def[min].as_location>|<def[max].as_location>].as_cuboid.min.simple>' 'id:dRegions_%world%_import'
- yaml set 'regions.%region%.max:<el@val[<def[min].as_location>|<def[max].as_location>].as_cuboid.max.simple>' 'id:dRegions_%world%_import'
}
# Set priority
- yaml set 'regions.%region%.priority:<yaml[dRegions_WGImport_%world%].read[regions.%region%.priority]>' 'id:dRegions_%world%_import'
# Set parent/child associations
- define parent '<yaml[dRegions_WGImport_%world%].read[regions.%region%.parent]||null>'
- if %parent% != null {
- yaml set 'regions.%region%.parent:%parent%' 'id:dRegions_%world%_import'
- if <yaml[dRegions_%world%_import].read[regions.%parent%.children].as_list||li@> !contains %region% {
- yaml set 'regions.%parent%.children:->:%region%' 'id:dRegions_%world%_import'
}
}
# Import members and owners
- define members-players '<yaml[dRegions_WGImport_%world%].read[regions.%region%.members.unique-ids].as_list.exclude[<yaml[dRegions_%world%_import].read[regions.%region%.members.players]||li@>]||li@>'
- foreach %members-players% {
- yaml set 'regions.%region%.members.players:->:%value%' 'id:dRegions_%world%_import'
}
- define members-groups '<yaml[dRegions_WGImport_%world%].read[regions.%region%.members.groups].as_list.exclude[<yaml[dRegions_%world%_import].read[regions.%region%.members.groups]||li@>]||li@>'
- foreach %members-groups% {
- yaml set 'regions.%region%.members.groups:->:%value%' 'id:dRegions_%world%_import'
}
- define owners-players '<yaml[dRegions_WGImport_%world%].read[regions.%region%.owners.unique-ids].as_list.exclude[<yaml[dRegions_%world%_import].read[regions.%region%.owners.players]||li@>]||li@>'
- foreach %owners-players% {
- yaml set 'regions.%region%.owners.players:->:%value%' 'id:dRegions_%world%_import'
}
- define owners-players '<yaml[dRegions_WGImport_%world%].read[regions.%region%.owners.groups].as_list.exclude[<yaml[dRegions_%world%_import].read[regions.%region%.owners.groups]||li@>]||li@>'
- foreach %owners-players% {
- yaml set 'regions.%region%.owners.groups:->:%value%' 'id:dRegions_%world%_import'
}
# Import flags
- define flags '<yaml[dRegions_WGImport_%world%].list_keys[regions.%region%.flags]||li@>'
- foreach %flags% {
- define flag '%value%'
- define mapping '<script.yaml_key[mapping.%flag%]||null>'
- if %mapping% == null {
- announce "<&b>dRegions<&co><&c> %flag% flag does not exist in dRegions!" to_console
- foreach next
}
- inject s@dRegions_WG_Importer 'p:<def[mapping].split[/].get[1]>'
}
flag_allowed-cmds:
- define commands '<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.allowed-cmds].as_list.parse[replace[/]]||li@>'
- yaml set 'regions.%region%.flags.commands:allow' 'id:dRegions_%world%_import'
- yaml set 'regions.%region%.flags.commands-list:<def[commands].separated_by[ ; ]>' 'id:dRegions_%world%_import'
flag_blocked-cmds:
- define commands '<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.allowed-cmds].as_list.parse[replace[/]]||li@>'
- yaml set 'regions.%region%.flags.commands:deny' 'id:dRegions_%world%_import'
- yaml set 'regions.%region%.flags.commands-list:<def[commands].separated_by[ ; ]>' 'id:dRegions_%world%_import'
flag_entity-explode:
- define currentState '<yaml[dRegions_%world%_import].read[regions.%region%.flags.entity-explode]||null>'
- define currentList '<yaml[dRegions_%world%_import].read[regions.%region%.flags.entity-explodelist].replace[, ].with[|].as_list||li@>'
- define flagVal '<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%]>'
- define entity '<def[flag].before[-]>'
- if %entity% == enderdragon {
- define entity 'ender_dragon'
}
else if %entity% == tnt {
- define entity 'primed_tnt|minecart_tnt'
}
else if %entity% == ghast {
- define entity 'fireball|small_fireball'
}
else if %entity% == other {
- define entity 'ender_crystal|fireball|small_fireball|wither|wither_skull'
}
- if %currentState% == null {
- yaml set 'regions.%region%.flags.entity-explode:%flagVal%' 'id:dRegions_%world%_import'
- yaml set 'regions.%region%.flags.entity-explodelist:<def[entity].as_list.comma_separated>' 'id:dRegions_%world%_import'
}
else if ( %currentState% == allow && %flagVal% == allow ) || ( %currentState% == deny && %flagVal% == deny ) {
- define newList '<def[currentList].include[%entity%].deduplicate>'
- if <def[newList].contains[creeper|ender_crystal|ender_dragon|primed_tnt|minecart_tnt|fireball|small_fireball|wither|wither_skull]> {
- define newList 'all'
}
else {
- define newList '<def[newList].comma_separated>'
}
- yaml set 'regions.%region%.flags.entity-explodelist:%newList%' 'id:dRegions_%world%_import'
}
- inject locally flag_entity-grief
flag_deny-spawn:
- define currentState '<yaml[dRegions_%world%_import].read[regions.%region%.flags.mob-spawn]||null>'
- define currentList '<yaml[dRegions_%world%_import].read[regions.%region%.flags.mob-spawnlist].replace[, ].with[|].as_list||li@>'
- define mobSpawn '<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.mob-spawning]||null>'
- define denySpawn '<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.deny-spawn]||null>'
- if %denySpawn% != null {
- yaml set 'regions.%region%.flags.mob-spawn:deny' 'id:dRegions_%world%_import'
- yaml set 'regions.%region%.flags.mob-spawnlist:<def[denySpawn].as_list.comma_separated>' 'id:dRegions_%world%_import'
}
else {
- yaml set 'regions.%region%.flags.mob-spawn:%mobSpawn%' 'id:dRegions_%world%_import'
}
flag_entity-grief:
- define currentState '<yaml[dRegions_%world%_import].read[regions.%region%.flags.entity-grief]||null>'
- define currentList '<yaml[dRegions_%world%_import].read[regions.%region%.flags.entity-grieflist].replace[, ].with[|].as_list||li@>'
- define flagVal '<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%]||null>'
- define entity '<def[flag].before[-]>'
- if %entity% == enderdragon {
- define entity 'ender_dragon'
}
else if %entity% == tnt {
- define entity 'primed_tnt|minecart_tnt'
}
else if %entity% == wither {
- define entity 'wither|wither_skull'
}
else if %entity% == ghast {
- define entity 'ghast|fireball|small_fireball'
}
else if %entity% == other {
- define entity 'ender_crystal|fireball|small_fireball|wither|wither_skull'
}
- if %currentState% == null {
- yaml set 'regions.%region%.flags.entity-grief:%flagVal%' 'id:dRegions_%world%_import'
- yaml set 'regions.%region%.flags.entity-grieflist:<def[entity].as_list.comma_separated>' 'id:dRegions_%world%_import'
}
else if ( %currentState% == allow && %flagVal% == allow ) || ( %currentState% == deny && %flagVal% == deny ) {
- define newList '<def[currentList].include[%entity%].deduplicate>'
- if <def[newList].contains[creeper|enderman|ender_dragon|ghast|fireball|small_fireball|primed_tnt|minecart_tnt|zombie|wither|wither_skull|sheep]> {
- define newList 'all'
}
else {
- define newList '<def[newList].comma_separated>'
}
- yaml set 'regions.%region%.flags.entity-grieflist:%newList%' 'id:dRegions_%world%_import'
}
flag_boolean:
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[2]>:<tern[<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%].is[==].to[deny]>]:false||true>' 'id:dRegions_%world%_import'
flag_generic:
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[2]>:<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%]>' 'id:dRegions_%world%_import'
flag_generic-list:
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[2]>:<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%]>' 'id:dRegions_%world%_import'
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[3]>:all' 'id:dRegions_%world%_import'
flag_generic-group:
- define group '<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%-group].replace[_].to_lowercase||null>'
- if %group% == null {
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[2]>:<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%]>' 'id:dRegions_%world%_import'
}
else {
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[2]>:<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%]>/%group%' 'id:dRegions_%world%_import'
}
flag_generic-list-group:
- define group '<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%-group].replace[_].to_lowercase||null>'
- if %group% == null {
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[2]>:<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%]>' 'id:dRegions_%world%_import'
}
else {
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[2]>:<yaml[dRegions_WGImport_%world%].read[regions.%region%.flags.%flag%]>/%group%' 'id:dRegions_%world%_import'
}
- yaml set 'regions.%region%.flags.<def[mapping].split[/].get[3]>:all' 'id:dRegions_%world%_import'
mapping:
# WorldGuard Flags
allowed-cmds: flag_allowed-cmds
blocked-cmds: flag_blocked-cmds
build: flag_generic-group/build
block-break: flag_generic-group/block-break
block-place: flag_generic-group/block-place
chest-access: flag_generic-list-group/chest-access/chest-access-blocks
deny-spawn: flag_deny-spawn
creeper-explosion: flag_entity-explode
ghast-fireball: flag_entity-explode
enderdragon-block-damage: flag_entity-explode
other-explosion: flag_entity-explode
tnt: flag_entity-explode
enderman-grief: flag_entity-grief
enderpearl: flag_generic-group/enderpearl
entity-item-frame-destroy: flag_generic/entity-break-itemframe
entity-painting-destroy: flag_generic/entity-break-painting
entry: flag_generic-group/entry
# entry-deny-message:
exit: flag_generic-group/exit
# exit-deny-message:
# exit-override:
# exit-via-teleport:
# exp-drops:
# fall-damage:
# farewell: flag_farewell
feed-amount: flag_generic-group/feed-amount
feed-delay: flag_generic/feed-delay
feed-max-hunger: flag_generic/feed-max
feed-min-hunger: flag_generic/feed-min
# fire-sread:
game-mode: flag_generic-group/gamemode
grass-growth: flag_generic/grass-spread
# greeting:
heal-amount: flag_generic-group/heal-amount
heal-delay: flag_generic/heal-delay
heal-max-health: flag_generic/heal-max
heal-min-health: flag_generic/heal-min
ice-form: flag_boolean/ice-form
ice-melt: flag_boolean/ice-melt
# interact:
invincible: flag_generic-list-group/player-damage/player-damage-types
item-drop: flag_generic-group/player-drops
item-pickup: flag_generic-group/player-pickup
# lava-fire:
lava-flow: flag_generic-list/lava-spread/lava-spreadblocks
leaf-decay: flag_boolean/leaf-decay
lighter: flag_generic-group/lighter
lightning: flag_generic-list/lightning-strike/lightning-strikeblocks
mob-damage: flag_generic-list-group/mob-damage/mob-damagelist
mob-spawning: flag_deny-spawn
mushroom-growth: flag_boolean/mushroom-spread
mycelium-spread: flag_boolean/mycel-spread
notify-enter: flag_boolean/notify-enter
notify-leave: flag_boolean/notify-exit
pistons: flag_boolean/pistons
potion-splash: flag_boolean/potion-throw
pvp: flag_boolean/pvp
# recieve-chat:
# ride:
send-chat: flag_generic-group/send-chat
sleep: flag_generic-group/sleep
snow-fall: flag_generic-list/snow-fall/snow-fallblocks
snow-melt: flag_boolean/snow-melt
soil-dry: flag_boolean/soil-dry
# spawn:
# teleport:
# time-lock:
# use:
vehicle-destroy: flag_generic-group/vehicle-destroy
vehicle-place: flag_generic-group/vehicle-place
vine-growth: flag_boolean/vine-spread
water-flow: flag_generic-list/water-spread/water-spreadblocks
# weather-lock:
# WorldRegions flags http://dev.bukkit.org/bukkit-plugins/worldregions/
# allow-blocks:
# deny-blocks:
# chat-prefix:
# chat-suffix:
# chunk-unload:
# cmds-block:
# cmds-allow:
# allow-pickup:
# death-drop-despawn-time:
# death-exp-despawn-time:
# drop-despawn-time:
# exp-despawn-time:
# enderpearls:
# allow-explosions:
# deny-explosions:
# fly:
# instabreak:
# keep-inventory:
# keep-level:
# mob-damage-allow:
# mob-damage-deny:
# allow-damage:
# deny-damage:
# player-enter-command:
# player-leave-command:
# server-enter-command:
# server-leave-command:
# effects:
# signs-allow:
# signs-block:
# respawn-location:
# texturepack:
# delta-time:
# fix-time:
# max-time:
# min-time:
# treefarm:
# WorldGuard Custom Flags http://dev.bukkit.org/bukkit-plugins/worldguard-custom-flags/pages/flags/
# allowed-break: flag_generic-list-group/block-break/block-breaklist
# allowed-damage:
# allowed-place: flag_generic-list-group/block-place/block-placelist
# apply-potion:
# blocked-break: flag_generic-list-group/block-break/block-breaklist
# blocked-damage:
# blocked-place: flag_generic-list-group/block-place/block-placelist
# healing:
# hunger:
# instabreak:
# item-pickup:
# item-spawn:
# mob-targeting:
# pve:
# regen:
sheep-eat: flag_entity-grief
# time:
wither-block-damage: flag_entity-grief
zombie-door-break: flag_entity-grief
################################################################################