319 lines
12 KiB
Python
319 lines
12 KiB
Python
from helpers import *
|
|
from basecommands import simplecommand, Validate, CommandException
|
|
from time import sleep
|
|
from collections import deque
|
|
import thread
|
|
import org.bukkit.event.block.BlockBreakEvent as BlockBreakEvent
|
|
import org.bukkit.block.Furnace as Furnace
|
|
import org.bukkit.inventory.ItemStack as ItemStack
|
|
import org.bukkit.Material as Material
|
|
import org.bukkit.event.block.Action as Action
|
|
import org.bukkit.block.BlockFace as BlockFace
|
|
import org.bukkit.scheduler.BukkitRunnable as BukkitRunnable
|
|
|
|
"""
|
|
# Permissions:
|
|
# - utils.toggle: for use of the command
|
|
# - utils.toggle.cauldron
|
|
# - utils.toggle.slab
|
|
# - utils.toggle.furnace
|
|
# - utils.toggle.piston
|
|
# - utils.toggle.dropper
|
|
# - utils.toggle.hopper
|
|
"""
|
|
|
|
settingInformation = dict( #[setting type, identifying description, detailed description, aliases, (optional) max slot id], setting types: 0 = toggle, default on. 1 = Set your setting to held itemstack, 2 = toggle, default off
|
|
cauldron = [0,
|
|
"easy cauldron water level control",
|
|
"Toggles whether cauldrons auto-fill upon placement and whether right clicking them with redstone dust or empty hand will cycle their water level",
|
|
["caul", "water"]
|
|
],
|
|
slab = [0,
|
|
"automatically flipping placed slabs upside-down",
|
|
"Toggles whether slabs/steps which you place should be automatically flipped upside-down",
|
|
["step"]
|
|
],
|
|
furnace = [1,
|
|
"automatically filling furnaces upon placement",
|
|
"Sets your preferred default furnace contents to your currently held itemstack. Use an empty hand to empty a slot, or /toggle furnace clear to clear all slots.",
|
|
["cooker", "fillf"], 2
|
|
],
|
|
torch = [0,
|
|
"removal of torches you place on redstone blocks",
|
|
"Toggles whether redstone torches which you place on redstone blocks will be deleted after a short amount of delay.",
|
|
["redstonetorch", "tor"]
|
|
],
|
|
piston = [2,
|
|
"rotating pistons, droppers and hoppers to face the block you place them against",
|
|
"Toggles whether pistons or sticky pistons which you place will be rotated to face the block which you placed them against.",
|
|
["invert", "rp"]
|
|
],
|
|
dropper = [1,
|
|
"automatically filling droppers upon placement",
|
|
"Sets your preferred default dropper contents to your currently held itemstack. Use an empty hand to empty a slot, or /toggle dropper clear to clear all slots.",
|
|
["itemshooter", "filld"], 8
|
|
],
|
|
hopper = [1,
|
|
"automatically filling hoppers upon placement",
|
|
"Sets your preferred default hopper contents to your currently held itemstack. Use an empty hand to empty a slot, or /toggle hopper clear to clear all slots.",
|
|
["itemtransporter", "fillh"], 4
|
|
]
|
|
)
|
|
|
|
defaults = {
|
|
0: list,
|
|
1: dict,
|
|
2: list
|
|
}
|
|
|
|
piston_faces = {
|
|
BlockFace.DOWN : 0,
|
|
BlockFace.UP : 1,
|
|
BlockFace.NORTH : 2,
|
|
BlockFace.SOUTH : 3,
|
|
BlockFace.WEST : 4,
|
|
BlockFace.EAST : 5
|
|
}
|
|
|
|
torch_faces = {
|
|
1: BlockFace.WEST,
|
|
2: BlockFace.EAST,
|
|
3: BlockFace.NORTH,
|
|
4: BlockFace.SOUTH,
|
|
5: BlockFace.DOWN
|
|
}
|
|
|
|
playerSettings = open_json_file("blockplacemods", {})
|
|
|
|
for setting, details in settingInformation.iteritems():
|
|
if playerSettings.get(setting) == None:
|
|
playerSettings[setting] = defaults[details[0]]()
|
|
|
|
def get(setting):
|
|
return playerSettings[setting]
|
|
|
|
def saveSettings():
|
|
save_json_file("blockplacemods", playerSettings)
|
|
|
|
def getSettingDetails(arg):
|
|
try:
|
|
arg = arg.lower()
|
|
for setting, details in settingInformation.iteritems():
|
|
if setting == arg or arg in details[3]:
|
|
return (setting, details)
|
|
except:
|
|
error(trace())
|
|
raise CommandException(" &cThat setting could not be found.\n For command help, use &o/toggle &cor &o/set")
|
|
|
|
@simplecommand("toggle",
|
|
aliases = ["setting", "set", "config"],
|
|
usage = "<setting> [value|info]",
|
|
description = "Toggles or sets your preferences for our redstone \nutilities. The following settings are available:\n" + ", ".join([x for x in settingInformation]),
|
|
senderLimit = 0,
|
|
helpNoargs = True,
|
|
helpSubcmd = True,
|
|
amax = 2)
|
|
def toggle_command(sender, command, label, args):
|
|
setting, details = getSettingDetails(args[0])
|
|
Validate.isAuthorized(sender, "utils.toggle." + setting, "that setting")
|
|
|
|
values = get(setting)
|
|
player = server.getPlayer(sender.getName())
|
|
uuid = uid(player)
|
|
arglen = len(args)
|
|
|
|
if details[0] in (0,2): # Toggle
|
|
default = details[0] == 0 # If True: toggle on if list doesn't contain the uuid
|
|
|
|
enabled = (uuid not in values) == default #Invert if details[0] == 2 (toggle disabled by default)
|
|
new = None
|
|
if arglen == 1:
|
|
new = not enabled
|
|
else:
|
|
arg2 = args[1].lower()
|
|
if arg2 == "info":
|
|
return " &aSetting %s:\n &9%s\n &6Accepted arguments: [on|enable|off|disable|toggle|switch|info]\n &6Aliases: %s" % (setting, details[2], ", ".join(details[3]))
|
|
elif arg2 in ("toggle", "switch"):
|
|
new = not enabled
|
|
elif arg2 in ("on", "enable"):
|
|
new = True
|
|
elif arg2 in ("off", "disable"):
|
|
new = False
|
|
else:
|
|
return " &cArgument '%s' was not recognized. \n Use &o/toggle %s info &cfor more information" % (arg2, setting)
|
|
if enabled is new:
|
|
return " &cAlready %s: &a%s" % ("enabled" if enabled else "disabled", details[1])
|
|
if new is default:
|
|
values.remove(uuid)
|
|
else:
|
|
values.append(uuid)
|
|
saveSettings()
|
|
return (" &aEnabled " if new else " &aDisabled ") + details[1]
|
|
|
|
|
|
elif details[0] == 1: # Save ItemStack in hand
|
|
arg2 = args[1].lower() if arglen > 1 else ""
|
|
enabled = uuid in values
|
|
|
|
if arg2 == "clear":
|
|
if enabled:
|
|
del values[uuid]
|
|
saveSettings()
|
|
return " &aDisabled " + details[1]
|
|
return " &cAlready disabled: " + details[1]
|
|
|
|
if arg2 == "info":
|
|
return " &aSetting %s:\n &9%s \n&6Accepted arguments: [<slot>|clear|details]" % (setting, details[2])
|
|
|
|
slot = int(arg2) if arg2.isdigit() else 0
|
|
if not (0 <= slot <= details[4]):
|
|
return " &cSlot number must be more than or equal to 0 and less than or equal to %s!" % details[4]
|
|
|
|
item = fromStack(player.getItemInHand())
|
|
if item[0] == 0 or item[1] <= 0:
|
|
if enabled:
|
|
items = values[uuid]
|
|
if slot in items:
|
|
del items[slot]
|
|
if len(items) == 0:
|
|
del items
|
|
saveSettings()
|
|
return " &aDisabled " + details[1]
|
|
saveSettings()
|
|
return " &aCleared slot %s of setting %s" % (slot, setting)
|
|
return " &cSlot %s of setting %s was already cleared!" % (slot, setting)
|
|
return " &cAlready disabled: " + details[1]
|
|
|
|
if arglen == 2 and not arg2.isdigit():
|
|
return " &cArgument '%s' was not recognized. \nUse &o/toggle %s info &cfor more information." % (arg2, setting)
|
|
|
|
if not enabled:
|
|
values[uuid] = {}
|
|
values[uuid][slot] = item
|
|
saveSettings()
|
|
return ((" &aEnabled setting %s, S" % setting) if len(values[uuid]) == 1 else " &aS") + "et itemstack in slot %s to item in hand" % (slot)
|
|
|
|
return None #This shouldn't happen
|
|
|
|
|
|
def fromStack(itemStack):
|
|
return [itemStack.getTypeId(), itemStack.getAmount(), itemStack.getData().getData()]
|
|
def toStack(lst):
|
|
return ItemStack(lst[0], lst[1], lst[2])
|
|
|
|
def isEnabled(toggleSetting, uuid):
|
|
return (uuid not in get(toggleSetting)) == (settingInformation[toggleSetting][0] == 0) #Invert if off by default
|
|
|
|
|
|
|
|
@hook.event("block.BlockPlaceEvent", "monitor")
|
|
def on_block_place(event):
|
|
try:
|
|
|
|
if event.isCancelled():
|
|
return
|
|
player = event.getPlayer()
|
|
if not is_creative(player):
|
|
return
|
|
|
|
uuid = uid(player)
|
|
block = event.getBlockPlaced()
|
|
material = block.getType()
|
|
|
|
|
|
if (material in (Material.WOOD_STEP, Material.STEP)
|
|
and isEnabled("slab", uuid)
|
|
and player.hasPermission("utils.toggle.slab")
|
|
and block.getData() < 8
|
|
):
|
|
block.setData(block.getData() + 8) # Flip upside down
|
|
|
|
|
|
elif (material == Material.CAULDRON
|
|
and isEnabled("cauldron", uuid)
|
|
and player.hasPermission("utils.toggle.cauldron")
|
|
):
|
|
block.setData(3) #3 layers of water, 3 signal strength
|
|
|
|
|
|
elif ((material == Material.FURNACE and player.hasPermission("utils.toggle.furnace"))
|
|
or (material == Material.DROPPER and player.hasPermission("utils.toggle.dropper"))
|
|
or (material == Material.HOPPER and player.hasPermission("utils.toggle.hopper"))
|
|
):
|
|
stacks = get(str(material).lower()).get(uuid)
|
|
if stacks != None: # Enabled
|
|
state = block.getState()
|
|
inv = state.getInventory()
|
|
for slot, stack in stacks.iteritems():
|
|
inv.setItem(int(slot), toStack(stack))
|
|
state.update()
|
|
|
|
|
|
elif (material == Material.REDSTONE_TORCH_ON
|
|
and isEnabled("torch", uuid)
|
|
and player.hasPermission("utils.toggle.torch")
|
|
and block.getData() in torch_faces
|
|
and block.getRelative(torch_faces[block.getData()]).getType() is Material.REDSTONE_BLOCK
|
|
):
|
|
torches_to_break.append(block)
|
|
|
|
|
|
elif (material in (Material.PISTON_BASE, Material.PISTON_STICKY_BASE)
|
|
and isEnabled("piston", uuid)
|
|
and player.hasPermission("utils.toggle.piston")
|
|
):
|
|
block.setData(piston_faces[block.getFace(event.getBlockAgainst())])
|
|
except:
|
|
error(trace())
|
|
|
|
|
|
@hook.event("player.PlayerInteractEvent", "monitor")
|
|
def on_interact(event):
|
|
player = event.getPlayer()
|
|
if (isEnabled("cauldron", uid(player))
|
|
and player.hasPermission("utils.toggle.cauldron")
|
|
and is_creative(player)
|
|
and event.getAction() == Action.RIGHT_CLICK_BLOCK
|
|
and (not event.hasItem() or event.getItem().getType() == Material.REDSTONE)
|
|
and event.getClickedBlock().getType() == Material.CAULDRON
|
|
):
|
|
block = event.getClickedBlock()
|
|
event2 = BlockBreakEvent(block, player)
|
|
server.getPluginManager().callEvent(event2)
|
|
if not event2.isCancelled():
|
|
block.setData(block.getData() - 1 if block.getData() > 0 else 3)
|
|
|
|
|
|
break_torches = True
|
|
torches_to_break = deque()
|
|
|
|
def stop_breaking_torches():
|
|
break_torches = False
|
|
info("[BlockPlaceMods] Interrupted torch breaking thread")
|
|
|
|
|
|
class JBukkitRunnable(BukkitRunnable):
|
|
|
|
def __init__(self, func):
|
|
self.run = func
|
|
|
|
|
|
def torch_breaker():
|
|
|
|
try:
|
|
if break_torches:
|
|
for i in range(len(torches_to_break)):
|
|
block = torches_to_break.popleft()
|
|
mat = block.getType()
|
|
if mat == Material.REDSTONE_TORCH_OFF:
|
|
block.setTypeId(0)
|
|
elif mat == Material.REDSTONE_TORCH_ON:
|
|
if block.getData() in torch_faces and block.getRelative(torch_faces[block.getData()]).getType() is Material.REDSTONE_BLOCK:
|
|
torches_to_break.append(block)
|
|
except:
|
|
error(trace())
|
|
|
|
|
|
def schedule_torch_breaker():
|
|
JBukkitRunnable(torch_breaker).runTaskTimer(server.getPluginManager().getPlugin("RedstonerUtils"), 0, 1)
|