RubySpellBooks.rb

Plugin.is {
        name "RubySpellBooks"
        version "0.8"
        author "RainbowReich"
        description "Allows Ruby code to be run from Written Books."
        commands :listbooks => {
            :description => "Lists all existing Ruby Spell Books.",
            :usage => "/listbooks"
        },
                        :binditem => {
            :description => "Binds an item to a Ruby Spell Book.",
            :usage => "/binditem"
        },
                        :reloadbook => {
            :description => "Reloads a Written Book as a Ruby Spell Book.",
            :usage => "/reloadbook"
        },
                        :editbook => {
            :description => "Opens a Written Book for editing.",
            :usage => "/editbook"
        },
                        :bindblock => {
            :description => "Binds the selected block to a Ruby Spell Book.",
            :usage => "/bindblock"
        }
}

import 'org.bukkit.Server'
import 'org.bukkit.event.player.PlayerInteractEvent'
import 'org.bukkit.Material'
import 'org.bukkit.event.entity.EntityDamageEvent'
import 'org.bukkit.event.entity.EntityDamageByEntityEvent'
import 'org.bukkit.event.entity.PlayerDeathEvent'
import 'org.bukkit.entity.HumanEntity'
import 'org.bukkit.Sound'
import 'org.bukkit.Effect'
import 'org.bukkit.ChatColor'
import 'org.bukkit.inventory.ItemStack'
import 'org.bukkit.entity.EntityType'
import 'org.bukkit.event.player.PlayerEditBookEvent'
import 'org.bukkit.event.player.PlayerPickupItemEvent'
import 'org.bukkit.event.entity.ItemDespawnEvent'
import 'org.bukkit.metadata.FixedMetadataValue'
import 'org.bukkit.event.player.PlayerMoveEvent'

require 'java'
require 'digest'



class SpellBook
    attr_accessor :code, :name, :author, :hash_code

    def initialize(name, author)
        @name = name
        @author = author
        @hash_code = ("#{@name} #{@author} #{@code}").hash
    end

    def run(context)
        eval(@code, context)
    end

    def ==(y)
        @hash_code.to_s == y[y.length-1] if y.class == Array
        self == y if y.class == SpellBook
    end

end

def spell_init &block
    yield unless $spell_init == false
end

def spell_run &block
    yield unless $spell_init == true
end

def spell_interact &block
    yield unless $spell_interact == false
end

def spell_pickup &block
    yield unless $spell_pickup == false
end

def spell_despawn &block
    yield unless $spell_despawn == false
end

def spell_move &block
    yield unless $spell_move == false
end

def set_player_variable(player) #Set Global Player Variable
    $player = player
end

def set_event_variable(event)
    $event = event
end

def reset_globals
    $spell_init = false
    $spell_interact = false
    $spell_pickup = false
    $spell_despawn = false
    $spell_move = false
end

def is_bound_item?(item)
    item.getItemMeta.hasLore && item.getItemMeta.getLore[0] == "Ruby Spell Bound"
end

def is_bound_block?(block)
    block.hasMetadata("reich") == true && block.getMetadata("reich")[0].value != nil
end

class RubySpellBooks < RubyPlugin

    attr_accessor :spell_books, :selected_block

    def create_spell_book(new_book, player) #Add Ruby Spell Book to internal list
        if new_book.getPages[0] == "Ruby Spell Book" then
            if @spell_books[new_book.getTitle] == nil then
                new_spell = SpellBook.new(new_book.getTitle, new_book.getAuthor)
                new_spell.code = new_book.getPages[1..new_book.getPages.length-1].join
                @spell_books[new_book.getTitle] = new_spell
                reset_globals
                $spell_init = true
                set_player_variable(player)
                new_spell.run(binding)
                return true
            else
                return false
            end
        end
    end

    def spawn_spell_item(world, loc, material, spell)
        spell_item = ItemStack.new(material)
        new_meta = spell_item.getItemMeta
        new_meta.setLore(["Ruby Spell Bound",spell])
        spell_item.setItemMeta new_meta
        world.dropItemNaturally(loc, spell_item)
    end

    def valid_spell? (s)
        !(@spell_books[s] == nil)
    end

    def onEnable #Enabled Plugin
        @spell_books = {}
        server.broadcastMessage "[" + description.name + "] " + description.fullName + " enabled."

        registerEvent(PlayerEditBookEvent, :Normal) do |event| #Ruby Spell Book Create Event
            new_book = event.getNewBookMeta
            set_event_variable(event)
            if event.isSigning == true && create_spell_book(new_book, event.getPlayer) == false then
                event.getPlayer.sendMessage("Could not create Ruby Spell Book.")
                event.setCancelled(true)
            end
        end

        registerEvent(PlayerInteractEvent, :Normal) do |event| #Use Bound Wand Event
            item = event.getPlayer.getInventory.getItemInHand
            if is_bound_item? item then
                set_event_variable(event)
                set_player_variable(event.getPlayer)
                reset_globals
                $spell_interact = true
                @spell_books[item.getItemMeta.getLore[1]].run(binding) if valid_spell? item.getItemMeta.getLore[1]
            end
            if item.getType == Material::STICK then #Select Block
                new_loc = event.getClickedBlock.getLocation
                new_loc.setY(new_loc.getY + 1)
                @selected_block = event.getClickedBlock.getWorld.getBlockAt(new_loc)
                event.getPlayer.sendMessage "Selected block at (#{@selected_block.getLocation.getX}, #{@selected_block.getLocation.getY}, #{@selected_block.getLocation.getZ})"
            end
        end

        registerEvent(PlayerPickupItemEvent, :Normal) do |event| #Pick up Bound Wand Event
            if is_bound_item? event.getItem.getItemStack then
                set_event_variable(event)
                set_player_variable(event.getPlayer)
                reset_globals
                $spell_pickup = true
                @spell_books[event.getItem.getItemStack.getItemMeta.getLore[1]].run(binding) #if valid_spell? event.getItem.getItemStack.getItemMeta.getLore[1]
            end
        end

        registerEvent(ItemDespawnEvent, :Normal) do |event| #Bound Wand Item despawn event
            if is_bound_item? event.getEntity.getItemStack then
                set_event_variable(event)
                set_player_variable(nil)
                reset_globals
                $spell_despawn = true
                @spell_books[event.getEntity.getItemStack.getItemMeta.getLore[1]].run(binding) if valid_spell? event.getEntity.getItemStack.getItemMeta.getLore[1]
            end
        end

        registerEvent(PlayerMoveEvent, :Normal) do |event| #Player Move over Bound Block Event
            cur_block = event.getPlayer.getWorld.getBlockAt(event.getTo)
            if is_bound_block?(cur_block)==true && valid_spell?(cur_block.getMetadata("reich")[0].value)==true then
                set_event_variable(event)
                set_player_variable(event.getPlayer)
                reset_globals
                $spell_move = true
                $block = cur_block
                @spell_books[cur_block.getMetadata("reich")[0].value].run(binding)
            end
        end

    end

    def onCommand(sender, command, label, args)
        if label == "listbooks" then #List Books Command
            @spell_books.length > 0 ? sender.sendMessage("Ruby Spell Books (#{@spell_books.length}):") : sender.sendMessage("No Ruby Spell Books exist.")
            @spell_books.each_value { |book| sender.sendMessage "#{book.name} by #{book.author}" }
            return true
        elsif label == "binditem" then #Bind Wand Command
            if @spell_books.has_key? args[0].to_s then
              new_meta = sender.getInventory.getItemInHand.getItemMeta
                new_meta.setLore(["Ruby Spell Bound", args[0].to_s])
                sender.getInventory.getItemInHand.setItemMeta new_meta
            else
                sender.sendMessage "#{args[0]} is not a valid Ruby Spell Book."
            end
            return true
        elsif label == "reloadbook" then #Reload Ruby Spell Book Command
            item = sender.getInventory.getItemInHand
            if item.getType == Material::WRITTEN_BOOK then
                if create_spell_book(item.getItemMeta, sender) == false then
                    sender.sendMessage("Could not create Ruby Spell Book.")
                end
            end
            return true
        elsif label == "editbook" then #Edit Book Command
            item = sender.getInventory.getItemInHand
            if item.getType == Material::WRITTEN_BOOK && item.getItemMeta.getAuthor == sender.getPlayerListName then
                item.setType(Material::BOOK_AND_QUILL)
                @spell_books.delete(item.getItemMeta.getTitle)
                return true
            end
        elsif label == "bindblock" then
            cur_block = @selected_block
            cur_block.setMetadata("reich", FixedMetadataValue.new(RubySpellBooks, args[0]))
            return true
        end
    end

    def onDisable #Disable Plugin
        server.broadcastMessage "[" + description.name + "] " + description.fullName + " disabled."
    end

end