"DeathBan_Signs":
type: world
events:
on player clicks in inventory:
- if <c.inventory.id_holder.is[==].to[Anvil]> {
- if <c.item.display.is[==].to[<white>R.I.P.]> {
- determine cancelled
}
}
on server start:
- if !<yaml.list.contains[DBServerSigns]> {
- if !<server.has_file[DeathBan/Signs/server.yml]> {
- yaml create 'id:DBServerSigns'
- yaml 'savefile:DeathBan/Signs/server.yml' 'id:DBServerSigns'
}
else yaml 'load:DeathBan/Signs/server.yml' 'id:DBServerSigns'
}
+ - if !<queue.exists[DB_SUpd_Exe]> && !<global.flag[DeathBan_SignUpdateTask].is[==].to[true]> {
+ - run s@DeathBan_Signs_Leaders 'path:SignUpdate' 'delay:60s'
+ }
+ - run s@DeathBan_Signs_Time_Update
on signs command:
- if !<context.server> {
- determine unfulfilled
}
- define player <c.args.get[1].as_player>
- run locally UpLimit 'player:%player%'
- determine fulfilled
on player changes sign:
- if <c.new.get[1]> == [DBSERV] && <player.has_permission[denizen.deathban.admin]> {
- if <c.new.get[2].as_int||true> {
- narrate "<green>DeathBan<&co> <red>Invalid Place!"
- determine cancelled
}
- if <c.new.get[2].is[==].to[0]||true> {
- narrate "<green>DeathBan<&co> <red>Invalid Place!"
- determine cancelled
}
- if !<server.has_file[DeathBan/Signs/server.yml]> {
- yaml create 'id:DBServerSigns'
- yaml 'savefile:DeathBan/Signs/server.yml' 'id:DBServerSigns'
}
- yaml set 'signs.<c.location.replace[.].with[-]>.place:<c.new.get[2]>' 'id:DBServerSigns'
- yaml set 'signs.<c.location.replace[.].with[-]>.loc:<c.location>' 'id:DBServerSigns'
- yaml 'savefile:DeathBan/Signs/server.yml' 'id:DBServerSigns'
- determine passively cancelled
- if <yaml[LeaderBoard].list_keys[leaders].contains[<c.new.get[2]>]> {
- define player <yaml[LeaderBoard].read[leaders.<c.new.get[2]>.player].as_player>
- define score <yaml[LeaderBoard].read[leaders.<c.new.get[2]>.score]>
- if <c.location.material.name.is[==].to[wall_sign]> {
- define dir <c.location.material.data>
- foreach li@2/n|3/s|4/w|5/e {
- if <def[value].before[/].is[==].to[%dir%]> {
- define dir <def[value].after[/]>
- sign <c.location.material.name> "<green>LEADER|<c.new.get[2]>|<aqua><def[player].name>|<white><def[score].as_int>" <c.location> 'direction:%dir%'
- foreach stop
}
}
}
else {
- define player <yaml[LeaderBoard].read[leaders.<c.new.get[2]>.player].as_player>
- define score <yaml[LeaderBoard].read[leaders.<c.new.get[2]>.score]>
- sign <c.location.material.name> "<green>LEADER|<c.new.get[2]>|<aqua><def[player].name>|<white><def[score].as_int>" <c.location>
}
else {
- sign <c.location.material.name> "" <c.location>
- queue clear
}
- if <c.new.get[1]> == [DB] && <player.has_permission[denizen.deathban.signs.leaders]> {
- if <player.flag[DeathBan_Leaders_Signs_Limit].is[OR_LESS].than[<player.flag[DeathBan_Leaders_Signs_Placed]>]> && !<player.has_permission[denizen.deathban.admin]> {
- narrate "<&a>DeathBan<&co> <&c>You cannot place anymore signs! Break one to place a new sign."
- determine cancelled
}
- define parameter <c.new.get[2].to[3].unseparated>
- if <def[parameter].as_player.is_player> {
- define type player
- define parameter <def[parameter].as_player>
}
else define type place
- if <def[type].is[==].to[place]> {
- yaml 'load:DeathBan/leaders.yml' 'id:<player.name>SignPlace'
- if !<yaml[<player.name>SignPlace].list_keys[Leaders].contains[%parameter%]> {
- narrate "<green>DeathBan<&co> <red>Invalid Place!"
- yaml unload 'id:<player.name>SignPlace'
- determine cancelled
}
- define UUID <yaml[<player.name>SignPlace].read[Leaders.%parameter%.player].as_player>
- define score <yaml[<player.name>SignPlace].read[Leaders.%parameter%.score].as_int>
- run s@DeathBan_Signs_Leaders 'def:%parameter%|%UUID%|%score%|<c.location>|<c.material>|%type%'
- determine cancelled
}
- if <def[type].is[==].to[player]> {
- define writeID <player.name>SignPlace
- yaml 'load:DeathBan/leaders.yml' 'id:%writeID%'
- foreach <yaml[%writeID%].list_keys[Leaders]> {
- define readPath Leaders.%value%.player
- if <yaml[%writeID%].read[%readPath%].is[==].to[<def[parameter].uuid>]> {
- define place %value%
- foreach stop
}
}
- define score <yaml[%writeID%].read[Leaders.%place%.score]>
- yaml unload 'id:%writeID%'
- run s@DeathBan_Signs_Leaders 'def:%place%|<def[parameter].as_player>|%score%|<c.location>|<c.material>|%type%'
- determine cancelled
}
- if <c.new.get[1]> == [TIME] && <player.has_permission[denizen.deathban.admin]> {
- flag server 'DeathBan_Signs_Time:->:<c.location>'
- run s@DeathBan_Signs_Time 'def:<c.location>|<c.material>'
}
on player breaks block:
- if <yaml[DBServerSigns].list_keys[signs].contains[<c.location.replace[.].with[-]>]> {
- if <player.has_permission[denizen.deathban.admin]> {
- yaml set 'signs.<c.location.replace[.].with[-]>:!' 'id:DBServerSigns'
- yaml 'savefile:DeathBan/Signs/server.yml' 'id:DBServerSigns'
- queue clear
}
else {
- narrate "<&a>DeathBan<&co> <&c>This sign is protected!"
- determine cancelled
}
}
- if <c.material.name.is[==].to[wall_sign]> || <c.material.name.is[==].to[sign_post]> {
- define line1 <c.location.sign_contents.get[1]>
- if %line1% == "<green>LEADER" {
- run s@DeathBan_Signs_Leaders 'path:RemoveSign' 'def:<c.location>'
- queue clear
}
- if %line1% == [TIME] && <global.flag[DeathBan_Signs_Time].as_list.contains[<c.location>]> {
- flag server 'DeathBan_Signs_Time:<-:<c.location>'
}
- if %line1% == '<white>R.I.P.' {
- if <player.has_permission[denizen.deathban.grave]> || <player.has_permission[denizen.deathban.admin]> {
- inject s@DeathBan_Grave 'path:SignBreak'
}
}
on player right clicks block:
#This event determines if a player is using a death tag on a blank wall sign.
- if <c.item.material.name.is[==].to[name_tag]||false> {
- inject s@DeathBan_Grave 'path:SignWrite'
}
-
- on server start:
- - if !<queue.exists[DB_SUpd_Exe]> && !<global.flag[DeathBan_SignUpdateTask].is[==].to[true]> {
+ UpLimit:
+ - ^flag player 'DeathBan_Signs_Leaders_Limit:++'
- - run s@DeathBan_Signs_Leaders 'path:SignUpdate' 'delay:60s'
- }
- - run s@DeathBan_Signs_Time_Update
- UpLimit:
- - ^flag player 'DeathBan_Signs_Leaders_Limit:++'
-
"DeathBan_Signs_Leaders":
type: task
script:
# 2 - North
# 3 - South
# 4 - West
# 5 - East
- ^if <def[5].name.is[==].to[wall_sign]> {
- define dir <def[5].data>
- foreach li@2/n|3/s|4/w|5/e {
- if <def[value].before[/].is[==].to[%dir%]> {
- define dir <def[value].after[/]>
- sign <def[5].name> "<green>LEADER|%1%|<aqua><def[2].name>|<white><def[3].as_int>" %4% 'direction:%dir%'
- foreach stop
}
}
}
else {
- sign <def[5].name> "<green>LEADER|%1%|<aqua><def[2].name>|<white><def[3].as_int>" %4%
}
- ^if !<player.has_permission[denizen.deathban.admin]> {
- flag player 'DeathBan_Leaders_Signs_Placed:++'
}
- ^inject locally SignListInit
- ^define writeID <player.name>SignPlace
- ^define locname <def[4].x.as_int>,<def[4].y.as_int>,<def[4].z.as_int>,<def[4].world.name>
- ^define readPath Signs.%locname%
- ^yaml 'load:DeathBan/SignList.yml' 'id:%writeID%'
- ^yaml 'write:%readPath%.loc' 'value:%4%' 'id:%writeID%'
- ^yaml 'write:%readPath%.type' 'value:%6%' 'id:%writeID%'
- ^yaml 'write:%readPath%.owner' 'value:<player.uuid>' 'id:%writeID%'
- ^if <def[6].is[==].to[player]> {
- yaml 'write:%readPath%.player' 'value:<def[2].uuid>' 'id:%writeID%'
}
- ^yaml 'savefile:DeathBan/SignList.yml' 'id:%writeID%'
- ^yaml unload 'id:%writeID%'
RemoveSign:
- ^define writeID <player.name>SignRemove
- ^define locname <def[1].x.as_int>,<def[1].y.as_int>,<def[1].z.as_int>,<def[1].world.name>
- ^yaml 'load:DeathBan/SignList.yml' 'id:%writeID%'
- ^if <yaml[%writeID%].list_keys[Signs].contains[%locname%]> {
- define readPath Signs.%locname%
- if <yaml[%writeID%].read[%readPath%.owner].is[==].to[<player.uuid>]> && !<player.has_permission[denizen.deathban.admin]> {
- flag player 'DeathBan_Leaders_Signs_Placed:--'
}
- yaml set '%readPath%:!' 'id:%writeID%'
- yaml 'savefile:DeathBan/SignList.yml' 'id:%writeID%'
- yaml unload 'id:%writeID%'
}
SignListInit:
- ^if !<server.has_file[DeathBan/SignList.yml]> {
- yaml create 'id:SignListInit'
- yaml set 'Signs.Init:true' 'id:SignListInit'
- yaml set 'Signs.Init:!' 'id:SignListInit'
- yaml 'savefile:DeathBan/SignList.yml' 'id:SignListInit'
- yaml unload 'id:SignListInit'
}
SignUpdate:
- ^flag server 'DeathBan_SignUpdateTask:true'
- ^define writeID SignUpdate
- ^define readID SignUpdateScores
- ^yaml 'load:DeathBan/SignList.yml' 'id:%writeID%'
- ^yaml 'load:DeathBan/leaders.yml' 'id:%readID%'
- ^if <yaml[DBServerSigns].list_keys[signs]||true> {
- wait 1t
- flag server 'DeathBan_SignUpdateTask:!'
- run locally 'path:SignUpdate_Execute' 'id:DB_SUpd_Exe' 'delay:60s'
- queue clear
}
- ^foreach <yaml[DBServerSigns].list_keys[signs]> {
- define loc <yaml[DBServerSigns].read[signs.%value%.loc]>
- if !<def[loc].get_chunk.is_loaded> {
- foreach next
}
- define place <yaml[DBServerSigns].read[signs.%value%.place]>
- if <yaml[LeaderBoard].list_keys[Leaders].contains[%place%]> {
- define player <yaml[LeaderBoard].read[Leaders.%place%.player].as_player>
- define score <yaml[LeaderBoard].read[Leaders.%place%.score]>
- if <def[loc].material.name.is[==].to[wall_sign]> {
- define dir <def[loc].material.data>
- foreach li@2/n|3/s|4/w|5/e {
- if <def[value].before[/].is[==].to[%dir%]> {
- define dir <def[value].after[/]>
- sign <def[loc].material.name> "<green>LEADER|%place%|<aqua><def[player].name||Unknown>|<white><def[score].as_int>" %loc% 'direction:%dir%'
- foreach stop
}
}
}
else {
- define player <yaml[LeaderBoard].read[Leaders.<c.new.get[2]>.player].as_player>
- define score <yaml[LeaderBoard].read[Leaders.<c.new.get[2]>.score]>
- sign <def[loc].material.name> "<green>LEADER|%place%|<aqua><def[player].name||Unknown>|<white><def[score].as_int>" %loc%
}
}
else if <def[loc].material.name.is[==].to[wall_sign]> {
- define dir <def[loc].material.data>
- foreach li@2/n|3/s|4/w|5/e {
- if <def[value].before[/].is[==].to[%dir%]> {
- define dir <def[value].after[/]>
- sign <def[loc].material.name> "|||" %loc% 'direction:%dir%'
- foreach stop
}
}
}
else {
- sign <def[loc].material.name> "|||" %loc%
}
}
- ^if <yaml[%writeID%].list_keys[Signs].is[==].to[null]> {
- wait 1t
- flag server 'DeathBan_SignUpdateTask:!'
- run locally 'path:SignUpdate_Execute' 'id:DB_SUpd_Exe' 'delay:60s'
- queue clear
}
- ^foreach <yaml[%writeID%].list_keys[Signs]> {
- define location <yaml[%writeID%].read[Signs.%value%.loc]>
- define key %value%
- if !<def[location].get_chunk.is_loaded> {
- foreach next
}
- define sign <def[location].material>
- if <def[sign].name.is[==].to[wall_sign]> {
- define dir <def[sign].data>
- foreach li@2/n|3/s|4/w|5/e {
- if <def[value].before[/].is[==].to[%dir%]> {
- define dir <def[value].after[/]>
- foreach stop
}
}
}
- if <yaml[%writeID%].read[Signs.%key%.type].is[==].to[place]> {
- define place <def[location].sign_contents.get[2]>
- if !<yaml[%readID%].list_keys[Leaders].contains[%place%]> {
- modifyblock %location% m@air
- define owner <yaml[%writeID%].read[Signs.%key%.owner].as_player>
- if <def[owner].is_player> && !<def[owner].has_permission[denizen.deathban.admin]> {
- flag %owner% 'DeathBan_Leaders_Signs_Placed:--'
}
- yaml set 'Signs.%key%:!' 'id:%writeID%'
- yaml 'savefile:DeathBan/SignList.yml' 'id:%writeID%'
- foreach next
}
- define player <yaml[%readID%].read[Leaders.%place%.player].as_player>
- define score <yaml[%readID%].read[Leaders.%place%.score].as_int>
- if <def[sign].name.is[==].to[wall_sign]> {
- sign <def[sign].name> "<green>LEADER|%place%|<aqua><def[player].name>|<white>%score%" %location% 'direction:%dir%'
- foreach next
}
else {
- sign <def[sign].name> "<green>LEADER|%place%|<aqua><def[player.name]>|<white>%score%" %location%
- foreach next
}
}
- if <yaml[%writeID%].read[Signs.%key%.type].is[==].to[player]> {
- define player <yaml[%writeID%].read[Signs.%key%.player].as_player>
- foreach <yaml[%readID%].list_keys[Leaders]> {
- define place %value%
- if <def[player].uuid.is[==].to[<yaml[%readID%].read[Leaders.%place%.player]>]> {
- define place %value%
- define score <yaml[%readID%].read[Leaders.%place%.score].as_int>
- foreach stop
}
}
- sign <def[sign].name> "<green>LEADER|%place%|<aqua><def[player].name>|<white>%score%" %location% 'direction:%dir%'
- foreach next
}
else {
- sign <def[sign].name> "<green>LEADER|%place%|<aqua><def[player].name>|<white>%score%" %location%
- foreach next
}
- if <def[sign].name.is[==].to[wall_sign]> {
- sign <def[sign].name> "Broken|Please Replace" %location% 'direction:%dir%'
}
else {
- sign <def[sign].name> "Broken|Please Replace" %location%
}
- define owner <yaml[%writeID%].read[Signs.%key%.owner].as_player>
- if <def[owner].is_player> && !<def[owner].has_permission[denizen.deathban.admin]> {
- flag %owner% 'DeathBan_Leaders_Signs_Placed:--'
}
- yaml set 'Signs.%key%:!' 'id:%writeID%'
- yaml 'savefile:DeathBan/SignList.yml' 'id:%writeID%'
}
- ^yaml unload 'id:%writeID%'
- ^yaml unload 'id:%readID%'
- ^flag server 'DeathBan_SignUpdateTask:!'
- ^wait 1t
- ^run locally 'path:SignUpdate_Execute' 'id:DB_SUpd_Exe' 'delay:15s'
- ^queue clear
SignUpdate_Execute:
- ^run locally 'path:SignUpdate'
"DeathBan_Grave":
type: task
script:
- ^if <player.location.world> !== w@Station {
- define TotalScore <yaml[<player.name>ScoreSheet].read[ScoreSheet.Current.Total]||0>
- define base <def[loc].sub[0,1,0]>
- if <def[base].material.name> == air {
- modifyblock %base% m@dirt
}
- modifyblock %loc% m@sign_post
- yaml 'load:DeathBan/ScoreSheets/<player.uuid>.yml' 'id:<player.name>Grave'
- define Time <yaml[<player.name>Grave].read[ScoreSheet.Current.SurvivalTime].as_duration||0s>
- sign "<white>R.I.P.|<aqua><player.name>|<green><def[Time].formatted||0s>|<def[totalscore].as_int>" %loc%
- yaml unload 'id:<player.name>Grave'
}
SignBreak:
- determine passively nothing
- define player <c.location.sign_contents.get[2]>
- define time <c.location.sign_contents.get[3]>
- define score <c.location.sign_contents.get[4]>
- give 'i@name_tag[display_name=R.I.P.;lore=%player%|%time%|%score%]' 'qty:1'
SignWrite:
#Player is using a name tag, is it a death tag?
- define tag <c.item>
- define score <def[tag].lore.get[3]>
- if !<def[tag].display.is[==].to[<white>R.I.P.]> && <def[score].is[==].[null]>
- determine cancelled
}
#Player has a death tag, are they clicking a sign?
- define material <c.location.material.name>
- if !<def[material].is[==].to[wall_sign]> && !<def[material].is[==].to[sign_post]> {
- determine cancelled
}
#Player has clicked a sign, do they have permission?
- if !<player.has_permission[denizen.deathban.grave]> && !<player.has_permission[denizen.deathban.admin]> {
- determine cancelled
}
#Player has permission let's work!
- define player <def[tag].lore.get[1]>
- define time <def[tag].lore.get[2]>
#If wall sign we need to determine direction
- if <def[material].is[==].to[wall_sign]> {
- define dir <c.location.material.data>
- foreach li@2/n|3/s|4/w|5/e {
- if <def[value].before[/].is[==].to[%dir%]> {
- define dir <def[value].after[/]>
- foreach stop
}
}
- sign %material% '<white>R.I.P.|%player%|%time%|%score%' <c.location> 'dir:%dir%'
}
else {
- sign %material% '<white>R.I.P.|%player%|%time%|%score%' <c.location>
}
- take %tag% 'qty:1'
- determine cancelled
"DeathBan_Signs_Time":
type: task
script:
- ^define time <w@Hardcore.time.period>
- ^if <def[time].is[==].to[dawn]> {
- define color "<green>"
}
else if <def[time].is[==].to[day]> {
- define color "<yellow>"
}
else if <def[time].is[==].to[dusk]> {
- define color "<gold>"
}
else if <def[time].is[==].to[night]> {
- define color "<red>"
}
- ^sign <def[2].name> "Time of Day|================|%color%<def[time].to_uppercase>|================" %1%
"DeathBan_Signs_Time_Update":
type: task
dawn: <green>
day: <yellow>
dusk: <gold>
night: <red>
script:
- ^while true {
- wait 30s
- define time <w@Hardcore.time.period>
- foreach <global.flag[DeathBan_Signs_Time].as_list> {
- sign type:automatic "Time of Day|================|<script.yaml_key[%time%]><def[time].to_uppercase>|=================" %value%
}
}
#
-