Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- options:
- C: &7
- H: &a
- Error: &c[Error]&6
- BroadcastScatters: true #Broadcast each time someone gets scattered?
- LoadChunks: true #Teleport the command sender to each chunk before scattering
- MaxTries: 1001 #How many times do you want to try to scatter before stopping?
- ChunkLoadTicks: 20 #How long to wait in between loading each chunk (ticks)
- ScatterTicks: 2 #How long inbetween teleporting each player to their scatter location
- DontLoadUnder: -1 #Set to a number if you dont want to load chunks UNDER this amount of players -1 or 0 for none
- Sounds: true
- ScatterSound: note.pling
- SoundVolume: 0.3
- SoundPitch: 0.5
- function barSquare(l: object):
- set {_l} to the location 2 below {_l}
- set block at {_l} to a barrier
- set (block at (the location 1 right {_l})) to a barrier
- set (block at (the location 1 left {_l})) to a barrier
- set (block at (the location 1 in front {_l})) to a barrier
- set (block at (the location 1 behind {_l})) to a barrier
- set (block at (the location 1 right and 1 above {_l})) to a barrier
- set (block at (the location 1 left and 1 above {_l})) to a barrier
- set (block at (the location 1 in front and 1 above {_l})) to a barrier
- set (block at (the location 1 behind and 1 above {_l})) to a barrier
- loop blocks in radius 2 around {_l}:
- loop-block is a barrier
- add loop-block to {barriersremove::*}
- command /sca [<int>] [<text>] [<text>]:
- aliases: /scatterall, /scatter
- permission: scatter.scatter
- trigger:
- if arg-1 is not set:
- send "{@Error} /sca <radius> <teams/*/player name/sb/sb2> [-load]"
- stop trigger
- else if arg-2 is not set:
- send "{@Error} /sca <radius> <teams/*/player name/sb/sb2> [-load]"
- stop trigger
- #-------------------------
- # Solos
- #-------------------------
- if arg-2 is "*" or "**" or "all" or "s" or "solo" or "solos":
- if size of {spec::*} is 0:
- if arg-3 is "-load":
- set {_fail} to false
- {_fail} is not set
- send "&7Scatter failed. No spectators to load chunks found. Use -load in the scatter to override this." to all ops
- stop trigger
- set {_ToScatter::*} to (all players)
- loop all players:
- {spec::%loop-player%} is true
- remove loop-player from {_ToScatter::*}
- set {_Size} to (size of {_ToScatter::*})
- set {_Mindist} to (arg-1/{_Size})*3.5
- hide all players from all players
- broadcast "{@C}Scattering {@H}%{_Size}%{@C} players with radius {@H}%arg-1%{@C} and mindist {@H}%{_Mindist}%"
- loop ({_Size}) times:
- loop {@MaxTries} times:
- if (loop-number-2) is {@MaxTries}:
- broadcast "{@C}Couldn't find locations for {@H}%({_Size})-(loop-number-1)%&0/{@H}%{_Size}%{@C} players!"
- stop trigger
- set {_Location.Good} to true
- set {_Location.Good} to true
- set {_XR} to random integer between {midx} + arg-1 and {midx} - arg-1
- set {_YR} to 250
- set {_ZR} to random integer between {midz} + arg-1 and {midz} - arg-1
- evaluate "set {_Location.Sky} to location at {_XR}, {_YR}, {_ZR} of the world ""uhc"""
- loop ((loop-number-1)-1) times:
- (distance between {_Location.Sky} and {_GoodLocation.Sky::%loop-number-3%}) is less than ({_Mindist})
- delete {_Location.Good}
- if {_Location.Good} is true:
- set {_GoodLocation.Sky::%loop-number-1%} to ({_Location.Sky})
- stop loop
- set {Scatter.DontUnloadChunks} to true
- if {@LoadChunks} is true:
- ({_Size}) is more than {@DontLoadUnder}
- set {_ExpectedTime} to ({_Size})*({@ChunkLoadTicks}/20)
- broadcast "{@C}Locations found, loading chunks!"
- broadcast "{@C}Loading chunks should take {@H}~%{_ExpectedTime}/size of {spec::*}%{@C} seconds."
- set {_LeftToLoad} to {_Size}
- while {_LeftToLoad} is greater than 0:
- loop {spec::*}:
- teleport ("%loop-index%" parsed as player) to location at {_GoodLocation.Sky::%{_LeftToLoad}%}
- remove 1 from {_LeftToLoad}
- wait {@ChunkLoadTicks} ticks
- wait "%(size of {spec::*} - 1)*7% ticks" parsed as timespan
- broadcast "{@H}Locations loaded. {@C}Now scattering."
- loop {ToScatter::*}:
- set {Scatter.Scattering::%loop-value%} to true
- wait 1 second
- set {_time} to now
- set {_Scattered} to 0
- loop {_ToScatter::*}:
- set {_Player} to "%loop-value%" parsed as offlineplayer
- add 1 to {_Scattered}
- if {_Player} is not online:
- broadcast " &7- {@H}%loop-value% &c-{@C} Scheduled Scatter"
- set {SchedueldScatter::%loop-value%} to location 1 above ({_GoodLocation.Sky::%{_Scattered}%})
- else:
- teleport (loop-value) to location 1 above ({_GoodLocation.Sky::%{_Scattered}%})
- barSquare({_GoodLocation.Sky::%{_Scattered}%})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%loop-value%{@C} scattered."
- command "/scattersound"
- wait {@ScatterTicks} ticks
- broadcast "{@C}Scatter has now {@H}finished! &c({@C}took {@H}%difference between now and {_time}%&c)"
- delete {Scatter.Scattering::*}
- delete {Scatter.DontUnloadChunks}
- reveal all players to all players
- #-------------------------
- # Teams
- #-------------------------
- else if arg-2 is "teams" or "t" or "team":
- if size of {spec::*} is 0:
- if arg-3 is "-load":
- set {_fail} to false
- {_fail} is not set
- send "&7Scatter failed. No spectators to load chunks found. Use -load in the scatter to override this." to all ops
- stop trigger
- set {_Count} to 0
- loop {Teams::*}:
- team loop-value is set
- increase {_Count} by 1
- set {_TeamScatter.%{_Count}%::*} to (team loop-value)
- loop all players:
- {Teams.InTeam::%loop-player%} is not set
- {spec::%loop-player%} is not set
- set {_Solos::%loop-player%} to loop-player
- set {_Size} to ({_Count}+(size of {_Solos::*}))
- set {_Mindist} to (arg-1/{_Size})*3.5
- hide all players from all players
- broadcast "{@C}Scattering {@H}%{_Count}%{@C} teams and {@H}%size of {_Solos::*}%{@C} solos with {@H}%{_Mindist}%{@C} mindist!"
- loop ({_Size}) times:
- loop {@MaxTries} times:
- if (loop-number-2) is {@MaxTries}:
- broadcast "{@C}Couldn't find locations for {@H}%({_Size})-(loop-number-1)%&0/{@H}%{_Size}%{@C} teams/solos!"
- stop trigger
- set {_Location.Good} to true
- set {_Location.Good} to true
- set {_XR} to random integer between {midx} + arg-1 and {midx} - arg-1
- set {_YR} to 250
- set {_ZR} to random integer between {midz} + arg-1 and {midz} - arg-1
- evaluate "set {_Location.Sky} to location at {_XR}, {_YR}, {_ZR} of the world ""uhc"""
- loop ((loop-number-1)-1) times:
- (distance between {_Location.Sky} and {_GoodLocation.Sky::%loop-number-3%}) is less than ({_Mindist})
- delete {_Location.Good}
- if {_Location.Good} is true:
- set {_GoodLocation.Sky::%loop-number-1%} to ({_Location.Sky})
- stop loop
- set {Scatter.DontUnloadChunks} to true
- if {@LoadChunks} is true:
- ({_Size}) is more than {@DontLoadUnder}
- set {_ExpectedTime} to ({_Size})*({@ChunkLoadTicks}/20)
- broadcast "{@C}Locations found, starting to load chunks!"
- broadcast "{@C}Loading chunks should take {@H}~%{_ExpectedTime}/size of {spec::*}%{@C} seconds."
- set {_LeftToLoad} to {_Size}
- while {_LeftToLoad} is greater than 0:
- loop {spec::*}:
- teleport ("%loop-index%" parsed as player) to location at {_GoodLocation.Sky::%{_LeftToLoad}%}
- remove 1 from {_LeftToLoad}
- wait {@ChunkLoadTicks} ticks
- wait "%(size of {spec::*} - 1)*7% ticks" parsed as timespan
- broadcast "{@H}Locations loaded. {@C}Now scattering."
- loop all players:
- set {Scatter.Scattering::%loop-player%} to true
- wait 1 second
- set {_TeamSize} to (size of {_Scatter.Teams::*})
- set {_SoloSize} to (size of {_Solos::*})
- set {_PositionCount} to 0
- set {_TeamCount} to 0
- set {_SoloCount} to 0
- set {_time} to now
- loop {_Count} times:
- increase {_PositionCount} by 1
- increase {_TeamCount} by 1
- if {@BroadcastScatters} is true:
- broadcast "{@C}Scattering Team {@H}%{_TeamCount}%{@C}:"
- loop {_TeamScatter.%{_TeamCount}%::*}:
- set {_Player} to ("%loop-value-2%" parsed as offlineplayer)
- if {_Player} is not online:
- broadcast " &7- {@H}%{_Player}% &c-{@C} Scheduled Scatter."
- set {SchedueldScatter::%{_Player}%} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- command "/scattersound"
- wait {@ScatterTicks} ticks
- else:
- teleport {_Player} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- barSquare({_GoodLocation.Sky::%{_PositionCount}%})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%{_Player}%{@C} scattered."
- command "/scattersound"
- wait {@ScatterTicks} ticks
- loop {_Solos::*}:
- increase {_PositionCount} by 1
- increase {_SoloCount} by 1
- if loop-value is not online:
- broadcast " &7- {@H}%loop-value% &c-{@C} Scheduled Scatter. &a&l(SOLO)"
- set {SchedueldScatter::%loop-value%} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- command "/scattersound"
- else:
- teleport loop-value to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- barSquare({_GoodLocation.Sky::%{_PositionCount}%})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%loop-value%{@C} scattered. &a&l(SOLO)"
- command "/scattersound"
- wait {@ScatterTicks} ticks
- broadcast "{@C}Scatter has now {@H}finished! &c({@C}took {@H}%difference between now and {_time}%&c)"
- delete {Scatter.Scattering::*}
- delete {Scatter.DontUnloadChunks}
- reveal all players to all players
- #-------------------------
- # Soul Brothers
- #-------------------------
- else if arg-2 is "soul" or "brothers" or "soulbrothers" or "sb":
- if size of {spec::*} is 0:
- if arg-3 is "-load":
- set {_fail} to false
- {_fail} is not set
- send "&7Scatter failed. No spectators to load chunks found. Use -load in the scatter to override this." to all ops
- stop trigger
- set {_Count} to 0
- loop {Teams::*}:
- team loop-value is set
- increase {_Count} by 1
- set {_TeamScatter.%{_Count}%::*} to (team loop-value)
- loop all players:
- {Teams.InTeam::%loop-player%} is not set
- {spec::%loop-player%} is not set
- set {_Solos::%loop-player%} to loop-player
- hide all players to all players
- set {_Size} to ({_Count}+(size of {_Solos::*}))
- set {_Mindist} to (arg-1/{_Size})*3.5
- broadcast "{@C}Scattering {@H}%{_Count}%{@C} teams and {@H}%size of {_Solos::*}%{@C} solos with {@H}%{_Mindist}%{@C} mindist!"
- loop ({_Size}) times:
- loop {@MaxTries} times:
- if (loop-number-2) is {@MaxTries}:
- broadcast "{@C}Couldn't find locations for {@H}%({_Size})-(loop-number-1)%&0/{@H}%{_Size}%{@C} teams/solos!"
- stop trigger
- set {_Location.Good} to true
- set {_Location.Good} to true
- set {_XR} to random integer between 0 + arg-1 and 0 - arg-1
- set {_YR} to 250
- set {_ZR} to random integer between 0 + arg-1 and 0 - arg-1
- evaluate "set {_Location.Sky} to location at {_XR}, {_YR}, {_ZR} of the world ""uhc3"""
- loop ((loop-number-1)-1) times:
- (distance between {_Location.Sky} and {_GoodLocation.Sky::%loop-number-3%}) is less than ({_Mindist})
- delete {_Location.Good}
- if {_Location.Good} is true:
- set {_GoodLocation.Sky::%loop-number-1%} to ({_Location.Sky})
- stop loop
- set {Scatter.DontUnloadChunks} to true
- if {@LoadChunks} is true:
- ({_Size}) is more than {@DontLoadUnder}
- set {_ExpectedTime} to ({_Size})*({@ChunkLoadTicks}/20)
- broadcast "{@C}Locations found, starting to load chunks!"
- broadcast "{@C}Loading chunks should take {@H}~%{_ExpectedTime}/size of {spec::*}%{@C} seconds."
- set {_LeftToLoad} to {_Size}
- while {_LeftToLoad} is greater than 0:
- loop {spec::*}:
- teleport ("%loop-index%" parsed as player) to location at {_GoodLocation.Sky::%{_LeftToLoad}%}
- remove 1 from {_LeftToLoad}
- wait {@ChunkLoadTicks} ticks
- wait "%(size of {spec::*} - 1)*7% ticks" parsed as timespan
- broadcast "{@H}Locations loaded. {@C}Now scattering."
- loop all players:
- set {Scatter.Scattering::%loop-player%} to true
- wait 1 second
- set {_TeamSize} to (size of {_Scatter.Teams::*})
- set {_SoloSize} to (size of {_Solos::*})
- set {_PositionCount} to 0
- set {_TeamCount} to 0
- set {_SoloCount} to 0
- set {_time} to now
- loop {_Count} times:
- increase {_PositionCount} by 1
- increase {_TeamCount} by 1
- if {@BroadcastScatters} is true:
- broadcast "{@C}Scattering Team {@H}%{_TeamCount}%{@C}:"
- loop {_TeamScatter.%{_TeamCount}%::*}:
- set {_Player} to ("%loop-value-2%" parsed as offlineplayer)
- add 1 to {_Team::%{_TeamCount}%}
- if {_Team::%{_TeamCount}%} is 1:
- if {_Player} is not online:
- broadcast " &7- {@H}%{_Player}% &c-{@C} Scheduled Scatter."
- set {SchedueldScatter::%{_Player}%} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- barSquare(({_GoodLocation.Sky::%{_PositionCount}%}))
- command "/scattersound"
- wait {@ScatterTicks} ticks
- else:
- teleport {_Player} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- barSquare({_GoodLocation.Sky::%{_PositionCount}%})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%{_Player}%{@C} scattered."
- command "/scattersound"
- wait {@ScatterTicks} ticks
- else:
- set {_x} to x-coordinate of {_GoodLocation.Sky::%{_PositionCount}%}
- set {_y} to y-coordinate of {_GoodLocation.Sky::%{_PositionCount}%} + 1
- set {_z} to z-coordinate of {_GoodLocation.Sky::%{_PositionCount}%}
- evaluate "set {_loc} to location at {_x}, {_y}, {_z} of the world ""uhc2"""
- if {_Player} is not online:
- broadcast " &7- {@H}%{_Player}% &c-{@C} Scheduled Scatter."
- set {SchedueldScatter::%{_Player}%} to {_loc}
- barSquare(location 1 below {_loc})
- command "/scattersound"
- wait {@ScatterTicks} ticks
- else:
- teleport {_Player} to {_loc}
- barSquare(location 1 below {_loc})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%{_Player}%{@C} scattered."
- command "/scattersound"
- wait {@ScatterTicks} ticks
- loop {_Solos::*}:
- increase {_PositionCount} by 1
- increase {_SoloCount} by 1
- if loop-value is not online:
- broadcast " &7- {@H}%loop-value% &c-{@C} Scheduled Scatter. &a&l(SOLO)"
- set {SchedueldScatter::%loop-value%} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- command "/scattersound"
- else:
- teleport loop-value to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- barSquare({_GoodLocation.Sky::%{_PositionCount}%})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%loop-value%{@C} scattered. &a&l(SOLO)"
- command "/scattersound"
- wait {@ScatterTicks} ticks
- broadcast "{@C}Scatter has now {@H}finished! &c({@C}took {@H}%difference between now and {_time}%&c)"
- delete {Scatter.Scattering::*}
- delete {Scatter.DontUnloadChunks}
- reveal all players to all players
- else if arg-2 is "soul2" or "brothers2" or "soulbrothers2" or "sb2":
- if size of {spec::*} is 0:
- if arg-3 is "-load":
- set {_fail} to false
- {_fail} is not set
- send "&7Scatter failed. No spectators to load chunks found. Use -load in the scatter to override this." to all ops
- stop trigger
- set {_Count} to 0
- loop {Teams::*}:
- team loop-value is set
- increase {_Count} by 1
- set {_TeamScatter.%{_Count}%::*} to (team loop-value)
- loop all players:
- {Teams.InTeam::%loop-player%} is not set
- {spec::%loop-player%} is not set
- set {_Solos::%loop-player%} to loop-player
- hide all players from all players
- set {_Size} to ({_Count}+(size of {_Solos::*}))
- set {_Mindist} to (arg-1/{_Size})*3.5
- broadcast "{@C}Scattering {@H}%{_Count}%{@C} teams and {@H}%size of {_Solos::*}%{@C} solos with {@H}%{_Mindist}%{@C} mindist!"
- loop ({_Size}) times:
- loop {@MaxTries} times:
- if (loop-number-2) is {@MaxTries}:
- broadcast "{@C}Couldn't find locations for {@H}%({_Size})-(loop-number-1)%&0/{@H}%{_Size}%{@C} teams/solos!"
- stop trigger
- set {_Location.Good} to true
- set {_Location.Good} to true
- set {_XR} to random integer between {midx} + arg-1 and {midx} - arg-1
- set {_YR} to 250
- set {_ZR} to random integer between {midz} + arg-1 and {midz} - arg-1
- evaluate "set {_Location.Sky} to location at {_XR}, {_YR}, {_ZR} of the world ""uhc"""
- loop ((loop-number-1)-1) times:
- (distance between {_Location.Sky} and {_GoodLocation.Sky::%loop-number-3%}) is less than ({_Mindist})
- delete {_Location.Good}
- if {_Location.Good} is true:
- set {_GoodLocation.Sky::%loop-number-1%} to ({_Location.Sky})
- stop loop
- set {Scatter.DontUnloadChunks} to true
- if {@LoadChunks} is true:
- ({_Size}) is more than {@DontLoadUnder}
- set {_ExpectedTime} to ({_Size})*({@ChunkLoadTicks}/20)
- broadcast "{@C}Locations found, starting to load chunks!"
- broadcast "{@C}Loading chunks should take {@H}~%{_ExpectedTime}/size of {spec::*}%{@C} seconds."
- set {_LeftToLoad} to {_Size}
- while {_LeftToLoad} is greater than 0:
- loop {spec::*}:
- teleport ("%loop-index%" parsed as player) to location at {_GoodLocation.Sky::%{_LeftToLoad}%}
- remove 1 from {_LeftToLoad}
- wait {@ChunkLoadTicks} ticks
- wait "%(size of {spec::*} - 1)*7% ticks" parsed as timespan
- broadcast "{@H}Locations loaded. {@C}Now scattering."
- loop all players:
- set {Scatter.Scattering::%loop-player%} to true
- wait 1 second
- set {_TeamSize} to (size of {_Scatter.Teams::*})
- set {_SoloSize} to (size of {_Solos::*})
- set {_PositionCount} to 0
- set {_TeamCount} to 0
- set {_SoloCount} to 0
- set {_time} to now
- loop {_Count} times:
- increase {_PositionCount} by 1
- increase {_TeamCount} by 1
- if {@BroadcastScatters} is true:
- broadcast "{@C}Scattering Team {@H}%{_TeamCount}%{@C}:"
- loop {_TeamScatter.%{_TeamCount}%::*}:
- set {_Player} to ("%loop-value-2%" parsed as offlineplayer)
- add 1 to {_Team::%{_TeamCount}%}
- set {nofall::%loop-value-2%} to true
- if {_Player} is not online:
- broadcast " &7- {@H}%{_Player}% &c-{@C} Scheduled Scatter."
- set {SchedueldScatter::%{_Player}%} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- else:
- teleport {_Player} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%{_Player}%{@C} scattered."
- command "/scattersound"
- wait {@ScatterTicks} ticks
- loop {_Solos::*}:
- increase {_PositionCount} by 1
- increase {_SoloCount} by 1
- set {nofall::%loop-value%} to true
- if loop-value is not online:
- broadcast " &7- {@H}%loop-value% &c-{@C} Scheduled Scatter. &a&l(SOLO)"
- set {SchedueldScatter::%loop-value%} to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- command "/scattersound"
- else:
- teleport loop-value to location 1 above ({_GoodLocation.Sky::%{_PositionCount}%})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%loop-value%{@C} scattered. &a&l(SOLO)"
- command "/scattersound"
- wait {@ScatterTicks} ticks
- broadcast "{@C}Scatter has now {@H}finished! &c({@C}took {@H}%difference between now and {_time}%&c)"
- delete {Scatter.Scattering::*}
- delete {Scatter.DontUnloadChunks}
- reveal all players to all players
- #-------------------------
- # 1 person
- #-------------------------
- else if ("%arg-2%" parsed as offlineplayer) is online:
- broadcast "{@C}Scattering {@H}%arg-2%{@C} with radius {@H}%arg-1%"
- loop {@MaxTries} times:
- if (loop-number-2) is {@MaxTries}:
- broadcast "{@C}Couldn't find a location for {@H}%arg-2%"
- stop trigger
- set {_Location.Good} to true
- set {_XR} to random integer between {midx} + arg-1 and {midx} - arg-1
- set {_YR} to 250
- set {_ZR} to random integer between {midz} + arg-1 and {midz} - arg-1
- evaluate "set {_Location.Sky} to location at {_XR}, {_YR}, {_ZR} of the world ""uhc"""
- if {_Location.Good} is true:
- set {_GoodLocation.Sky} to ({_Location.Sky})
- stop loop
- set {nodamage::%arg-2%} to true
- teleport ("%arg-2%" parsed as offlineplayer) to ({_GoodLocation.Sky})
- if {@BroadcastScatters} is true:
- broadcast " &7- {@H}%arg-2%{@C} scattered."
- command "/scattersound"
- wait 30 seconds
- wait 30 seconds
- delete {nodamage::%arg-2%}
- else:
- send "{@Error} Couldnt get {@H}&0&l""{@C}%arg-2%&0&l""{@H}"
- send "{@Error} /sca <radius> <teams/*/player name/sb/sb2> [-load]"
- on skript load:
- delete {Scatter.DontUnloadChunks}
- delete {Scatter.Scattering::*}
- delete {nodamage::*}
- delete {nofall::*}
- command /scattersound:
- permission: scatter.sound
- trigger:
- {@Sounds} is true
- loop all players:
- command "/playsound {@ScatterSound} %loop-player% ~ ~ ~ {@SoundVolume} {@SoundPitch} {@SoundVolume}"
- on chat:
- {Scatter.Scattering::*} is set
- set {nochat::%player%} to true
- on damage of a player:
- if {nodamage::%victim%} is true:
- cancel the event
- if damage cause is fall:
- {nofall::%victim%} is true
- cancel the event
- delete {nofall::%victim%}
- on login:
- if {SchedueldScatter::%player%} is set:
- teleport (player) to ({SchedueldScatter::%player%})
- set {nodamage::%player%} to true
- delete {SchedueldScatter::%player%}
- broadcast "{@H}%player%{@C} has been scheduled a late scatter!"
- command "/scattersound"
- wait 30 seconds
- delete {nodamage::%player%}
- else if {SafeFromDeath::%player%} is true:
- set {nodamage::%player%} to true
- wait 30 seconds
- delete {nodamage::%player%}
- on join:
- if {Scatter.Scattering::*} is set:
- hide player from all players
- else if {Scatter.DontUnloadChunks} is true:
- hide player from all players
- on quit:
- if {Scatter.Scattering::*} is set:
- set {SafeFromDeath::%player%} to true
- reveal player to all players
- else if {Scatter.DontUnloadChunks} is true:
- set {SafeFromDeath::%player%} to true
- reveal player to all players
- delete {Scatter.Scattering::%player%}
- on chunk unload:
- {Scatter.DontUnloadChunks} is true
- cancel the event
- on damage of a player:
- {Scatter.Scattering::%victim%} is true
- cancel the event
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement