mcblocky 0.1.0.pre.alpha.pre.6

data/lib/mcblocky/dsl.rb

@@ -0,0 +1,146 @@
+load File.expand_path('dsl/selector.rb', File.dirname(__FILE__))
+load File.expand_path('dsl/commands.rb', File.dirname(__FILE__))
+load File.expand_path('dsl/repeat_chain.rb', File.dirname(__FILE__))
+load File.expand_path('dsl/command_block.rb', File.dirname(__FILE__))
+load File.expand_path('dsl/block.rb', File.dirname(__FILE__))
+load File.expand_path('dsl/container.rb', File.dirname(__FILE__))
+require 'json'
+
+module McBlocky
+  module DSL
+    def helper(*command, &block)
+      context.helpers << [command, block]
+    end
+
+    def initial(&block)
+      chain = Commands.new(:initial)
+      chain.instance_exec(&block)
+      chains << chain
+    end
+
+    def cleanup(&block)
+      chain = Commands.new(:cleanup)
+      chain.instance_exec(&block)
+      chains << chain
+    end
+
+    def after(&block)
+      chain = Commands.new(:after)
+      chain.instance_exec(&block)
+      chains << chain
+    end
+
+    def repeat(x1, y1, z1, x2, y2, z2, &block)
+      chain = RepeatChain.new(x1, y1, z1, x2, y2, z2)
+      chain.instance_exec(&block)
+      chains << chain
+    end
+
+    def at(x, y, z, data=0, kind=:normal, nbt={}, &block)
+      if Symbol === data
+        kind = data
+        data = 0
+      end
+      block_kind = case kind
+                   when :normal
+                     'minecraft:command_block'
+                   when :chain
+                     'minecraft:chain_command_block'
+                   when :repeating
+                     'minecraft:repeating_command_block'
+                   else
+                     raise ArgumentError, 'Unknown command block type'
+                   end
+      cblock = CommandBlock.new(x, y, z, data, block_kind, nbt)
+      cblock.instance_exec(&block)
+      blocks[Location.new(x, y, z)] = cblock
+    end
+
+    def setblock(x, y, z, kind, data=0, replacemode='replace', nbt={})
+      block = Block.new(x, y, z, kind, data, nbt)
+      blocks[Location.new(x, y, z)] = block
+    end
+
+    def fill(x1, y1, z1, x2, y2, z2, kind, data=0)
+      block = Block.new(nil, nil, nil, kind, data)
+      rects[Rect.new(x1, y1, z1, x2, y2, z2)] = block
+    end
+
+    def chest(x, y, z, data=0, &block)
+      container = Container.new(x, y, z, 'minecraft:chest', data)
+      container.instance_exec(&block)
+      blocks[Location.new(x, y, z)] = container
+    end
+
+    def trapped_chest(x, y, z, data=0, &block)
+      container = Container.new(x, y, z, 'minecraft:trapped_chest', data)
+      container.instance_exec(&block)
+      blocks[Location.new(x, y, z)] = container
+    end
+
+    def dispenser(x, y, z, data=0, &block)
+      container = Container.new(x, y, z, 'minecraft:dispenser', data)
+      container.instance_exec(&block)
+      blocks[Location.new(x, y, z)] = container
+    end
+
+    def dropper(x, y, z, data=0, &block)
+      container = Container.new(x, y, z, 'minecraft:dropper', data)
+      container.instance_exec(&block)
+      blocks[Location.new(x, y, z)] = container
+    end
+
+    def furnace(x, y, z, data=0, &block)
+      container = Container.new(x, y, z, 'minecraft:furnace', data)
+      container.instance_exec(&block)
+      blocks[Location.new(x, y, z)] = container
+    end
+
+    def to_nbt(obj)
+      case obj
+      when String
+        JSON.dump(obj)
+      when Fixnum, Float
+        obj.to_s
+      when Array
+        "[#{obj.map{|x| to_nbt x}.join(',')}]"
+      when Hash
+        pairs = obj.map do |k,v|
+          "#{k}:#{to_nbt v}"
+        end
+        "{#{pairs.join(',')}}"
+      else
+        raise ArgumentError, "No NBT form for #{obj}"
+      end
+    end
+    module_function :to_nbt
+
+    module Facing
+      DOWN = 0
+      UP = 1
+      NORTH = 2
+      SOUTH = 3
+      WEST = 4
+      EAST = 5
+    end
+
+    module Color
+      WHITE = 0
+      ORANGE = 1
+      MAGENTA = 2
+      LIGHT_BLUE = 3
+      YELLOW = 4
+      LIME = 5
+      PINK = 6
+      GRAY = 7
+      LIGHT_GRAY = 8
+      CYAN = 9
+      PURPLE = 10
+      BLUE = 11
+      BROWN = 12
+      GREEN = 13
+      RED = 14
+      BLACK = 15
+    end
+  end
+end

data/lib/mcblocky/executor.rb

@@ -0,0 +1,149 @@
+module McBlocky
+  class Executor < DSL::Commands
+    def self.to_commands(context, old_context=nil)
+      executor = Executor.new(:final)
+      executor.do_context(context, old_context)
+      executor.commands
+    end
+
+    def do_context(context, old_context)
+      # do cleanup first
+      if old_context
+        old_context.chains.select{|x|x.kind == :cleanup}.each do |c|
+          self.commands += c.commands
+        end
+      end
+
+      # do initial blocks
+      old_initials = old_context ? old_context.chains.select{|x|x.kind == :initial} : []
+      initials = context.chains.select{|x|x.kind == :initial}
+      initials.each_with_index do |chain, i|
+        old_chain = old_initials[i]
+        if old_chain
+          matches = true
+          chain.commands.each_with_index do |cmd, j|
+            if matches
+              old_cmd = old_chain.commands[j]
+              next if old_cmd == cmd
+              matches = false
+              command cmd
+            else
+              command cmd
+            end
+          end
+        else
+          chain.commands.each {|cmd| command cmd}
+        end
+      end
+
+      if old_context
+        old_context.areas.each do |x1, y1, z1, x2, y2, z2|
+          fill x1, y1, z1, x2, y2, z2, 'minecraft:air'
+        end
+      end
+      context.areas.each do |x1, y1, z1, x2, y2, z2|
+        fill x1, y1, z1, x2, y1, z2, 'minecraft:stained_glass', '7'
+        fill x1, y2, z1, x2, y2, z2, 'minecraft:stained_glass', '7'
+        fill x1, y1, z1, x1, y2, z2, 'minecraft:stained_glass', '7'
+        fill x2, y1, z1, x2, y2, z2, 'minecraft:stained_glass', '7'
+        fill x1, y1, z1, x2, y2, z1, 'minecraft:stained_glass', '7'
+        fill x1, y1, z2, x2, y2, z2, 'minecraft:stained_glass', '7'
+      end
+
+      rects = (old_context ? old_context.rects.keys : []) + context.rects.keys
+      rects.uniq.each do |rect|
+        old_block = old_context ? old_context.rects[rect] : nil
+        block = context.rects[rect]
+        if old_block and !block
+          fill rect.x1, rect.y1, rect.z1, rect.x2, rect.y2, rect.z2, 'minecraft:air'
+        elsif old_block and old_block != block
+          fill rect.x1, rect.y1, rect.z1, rect.x2, rect.y2, rect.z2, block.block_kind, block.block_data, 'replace', old_block.block_kind, old_block.block_data
+        else
+          fill rect.x1, rect.y1, rect.z1, rect.x2, rect.y2, rect.z2, block.block_kind, block.block_data
+        end
+      end
+
+      context.chains.select{|x|x.kind == :repeat}.each do |c|
+        do_repeat context, c
+      end
+
+      locations = (old_context ? old_context.blocks.keys : []) + context.blocks.keys
+      locations.uniq.each do |loc|
+        old = old_context ? old_context.blocks[loc] : nil
+        new = context.blocks[loc]
+        do_block(new, old)
+      end
+
+      # after blocks are set
+      context.chains.select{|x|x.kind == :after}.each do |c|
+        self.commands += c.commands
+      end
+    end
+
+    def do_block(block, old_block=nil)
+      if old_block and !block
+        setblock old_block.x, old_block.y, old_block.z, 'minecraft:air'
+        return
+      end
+
+      if old_block and old_block.block_kind == block.block_kind and old_block.block_data == block.block_data
+        return if old_block.nbt == block.nbt
+        blockdata block.x, block.y, block.z, block.nbt unless block.nbt == {}
+      else
+        setblock block.x, block.y, block.z, block.block_kind, block.block_data, 'replace'
+        blockdata block.x, block.y, block.z, block.nbt unless block.nbt == {}
+      end
+    end
+
+    def do_repeat(context, chain)
+      sequence = fill_space(chain.rect)
+      if chain.commands.length > sequence.length
+        raise ArgumentError, "Chain is too long for the provided space"
+      end
+      kind = 'minecraft:repeating_command_block'
+      chain.commands.each_with_index do |c,i|
+        cursor = sequence[i]
+        next_cursor = if i+1 < sequence.length
+                        sequence[i+1]
+                      else
+                        Location.new(cursor.x, cursor.y+1, cursor.z)
+                      end
+        facing = if next_cursor.x - cursor.x == 1
+                   DSL::Facing::EAST
+                 elsif next_cursor.x - cursor.x == -1
+                   DSL::Facing::WEST
+                 elsif next_cursor.y - cursor.y == 1
+                   DSL::Facing::UP
+                 elsif next_cursor.y - cursor.y == -1
+                   DSL::Facing::DOWN
+                 elsif next_cursor.z - cursor.z == 1
+                   DSL::Facing::SOUTH
+                 elsif next_cursor.z - cursor.z == -1
+                   DSL::Facing::NORTH
+                 end
+        context.blocks[cursor] = DSL::CommandBlock.new(cursor.x, cursor.y, cursor.z, facing, kind, {'auto'=>1})
+        context.blocks[cursor].command c
+        kind = 'minecraft:chain_command_block'
+      end
+    end
+
+    def fill_space(rect)
+      path = []
+      zrange = rect.z1..rect.z2
+      zrange.each do |z|
+        rz = z - rect.z1
+        yrange = rect.y1..rect.y2
+        yrange = yrange.to_a.reverse if rz % 2 != 0
+        yrange.each do |y|
+          ry = y - rect.y1
+          xrange = rect.x1..rect.x2
+          xrange = xrange.to_a.reverse if (ry+rz) % 2 != 0
+          xrange.each do |x|
+            path << Location.new(x, y, z)
+          end
+        end
+      end
+      path
+    end
+  end
+end

data/lib/mcblocky/listener.rb

@@ -0,0 +1,69 @@
+require 'listen'
+require 'mcblocky/logging'
+
+module McBlocky
+  class Listener
+    include Logging
+
+    def self.from_config(&block)
+      Config.validate
+      return Listener.new(File.dirname(Config.config_path), Config.config['code']['main'], &block)
+    end
+
+    def initialize(dir, main, &block)
+      @dir = dir
+      @main = main
+      @initial_files = [
+        @main,
+        File.expand_path('../dsl.rb', __FILE__),
+        File.expand_path('../dsl/commands.rb', __FILE__),
+        File.expand_path('../dsl/repeat_chain.rb', __FILE__),
+        File.expand_path('../dsl/selector.rb', __FILE__),
+        File.expand_path('../dsl/command_block.rb', __FILE__),
+        File.expand_path('../dsl/block.rb', __FILE__),
+        File.expand_path('../dsl/container.rb', __FILE__),
+        File.expand_path('../context.rb', __FILE__),
+        File.expand_path('../executor.rb', __FILE__),
+      ]
+      @files = @initial_files
+      @listener = Listen.to(dir, File.dirname(__FILE__), only: /\.rb$/, &method(:handle))
+      @handler = block
+    end
+
+    def start
+      @listener.start
+      begin
+        log_status "Loading"
+        result = Context.run_file(@main, @dir)
+      rescue Exception
+        log_error "Error in loaded file:"
+        puts $!
+        return
+      end
+      @handler.call(result)
+      @files = @initial_files + result.required_files.to_a if result.required_files
+    end
+
+    def handle(modified, added, removed)
+      @files.each do |f|
+        f = File.expand_path(f, @dir).gsub('\\','/')
+        if modified.include? f or added.include? f or removed.include? f
+          begin
+            log_status "Reloading..."
+            McBlocky.reload!
+            result = Context.run_file(@main, @dir)
+          rescue Exception => e
+            log_error "Error in loaded file:"
+            puts e.backtrace.join("\n\t")
+              .sub("\n\t", ": #{e}#{e.class ? " (#{e.class})" : ""}\n\t")
+            break
+          end
+          @handler.call(result)
+          @files = @initial_files + result.required_files.to_a if result.required_files
+          log_status "Reloaded."
+          break
+        end
+      end
+    end
+  end
+end

data/lib/mcblocky/location.rb

@@ -0,0 +1,95 @@
+module McBlocky
+  class Location < Struct.new(:x, :y, :z)
+    def +(other)
+      if other.is_relative?
+        Location.new(x + other.x, y + other.y, z + other.z)
+      else
+        RelativeLocation.new(x + other.x, y + other.y, z + other.z)
+      end
+    end
+
+    def -(other)
+      if other.is_relative?
+        Location.new(x - other.x, y - other.y, z - other.z)
+      else
+        RelativeLocation.new(x - other.x, y - other.y, z - other.z)
+      end
+    end
+
+    def is_relative?
+      false
+    end
+  end
+
+  class RelativeLocation < Location
+    def +(other)
+      if other.is_relative?
+        RelativeLocation.new(x + other.x, y + other.y, z + other.z)
+      else
+        Location.new(x + other.x, y + other.y, z + other.z)
+      end
+    end
+
+    def -(other)
+      if other.is_relative?
+        RelativeLocation.new(x - other.x, y - other.y, z - other.z)
+      else
+        Location.new(x - other.x, y - other.y, z - other.z)
+      end
+    end
+
+    def is_relative?
+      true
+    end
+  end
+
+  class Rect < Struct.new(:x1, :y1, :z1, :x2, :y2, :z2)
+    def initialize(*args)
+      if args.length == 6
+        super
+      elsif args.length == 2
+        super(args[0].x, args[0].y, args[0].z, args[1].x, args[1].y, args[1].z)
+      elsif args.length == 4
+        if args[0].respond_to? :x
+          super(args[0].x, args[0].y, args[0].z, args[1], args[2], args[3])
+        elsif args[3].respond_to? :x
+          super(args[0], args[1], args[2], args[3].x, args[3].y, args[3].z)
+        else
+          raise ArgumentError
+        end
+      else
+        raise ArgumentError
+      end
+
+      if x1 > x2
+        self.x1, self.x2 = self.x2, self.x1
+      end
+      if y1 > y2
+        self.y1, self.y2 = self.y2, self.y1
+      end
+      if z1 > z2
+        self.z1, self.z2 = self.z2, self.z1
+      end
+    end
+
+    def p1
+      @p1 ||= Location.new(x1, y1, z1)
+    end
+
+    def p2
+      @p2 ||= Location.new(x2, y2, z2)
+    end
+
+    def w
+      x2 - x1
+    end
+
+    def h
+      y2 - y1
+    end
+
+    def d
+      z2 - z1
+    end
+  end
+end

data/lib/mcblocky/logging.rb

@@ -0,0 +1,45 @@
+module McBlocky
+  module Logging
+    RESET   = "\e[0m"
+    BOLD    = "\e[1m"
+    RED     = "\e[31m"
+    GREEN   = "\e[32m"
+    YELLOW  = "\e[33m"
+    BLUE    = "\e[34m"
+    MAGENTA = "\e[35m"
+    CYAN    = "\e[36m"
+    WHITE   = "\e[37m"
+
+    @@mutex = Mutex.new
+
+    def log_server(message)
+      @@mutex.synchronize do
+        puts "#{YELLOW}#{message.chomp}#{RESET}"
+      end
+    end
+
+    def log_message(message)
+      @@mutex.synchronize do
+        puts "#{MAGENTA}#{message.chomp}#{RESET}"
+      end
+    end
+
+    def log_command(message)
+      @@mutex.synchronize do
+        puts "#{CYAN}#{BOLD}/#{message.chomp}#{RESET}"
+      end
+    end
+
+    def log_status(message)
+      @@mutex.synchronize do
+        puts "#{GREEN}#{BOLD}---> #{message.chomp}#{RESET}"
+      end
+    end
+
+    def log_error(message)
+      @@mutex.synchronize do
+        puts "#{RED}#{BOLD}---> #{message.chomp}#{RESET}"
+      end
+    end
+  end
+end

data/lib/mcblocky/server.rb

@@ -0,0 +1,143 @@
+require "open3"
+require "mcblocky/logging"
+
+module McBlocky
+  class ServerShutdown < StandardError; end
+  class Server
+    include Logging
+    def self.from_config
+      Config.validate
+      server = Config.config['server']
+      workdir = File.expand_path(server['workdir'], File.dirname(Config.config_path))
+      Dir.mkdir workdir unless Dir.exist? workdir
+      Dir.chdir workdir do
+        if server['eula']
+          open('eula.txt', 'w') do |f|
+            f.write("eula=true#{$/}")
+          end
+        end
+
+        set_server_properties(server['properties'])
+      end
+      return Server.new(server['jar'], workdir, server['java'], server['ops'])
+    end
+
+    def self.set_server_properties(properties, filename='server.properties')
+      lines = if File.exist? filename
+                open(filename).readlines
+              else
+                []
+              end
+      properties.each do |k,v|
+        if !lines.select{|l| l.start_with? "#{k}="}.empty?
+          lines.map! do |l|
+            if l.start_with? "#{k}="
+              "#{k}=#{v}#{$/}"
+            else
+              l
+            end
+          end
+        else
+          lines << "#{k}=#{v}#{$/}"
+        end
+      end
+      IO.write(filename, lines.join(''))
+    end
+
+    def initialize(jar, workdir, java=nil, ops=nil)
+      @java = java || 'java'
+      @jar = jar
+      @workdir = workdir
+      @queue = Queue.new
+      @matchers = []
+      @message_matchers = []
+      @ops = ops
+    end
+
+    def start
+      Dir.chdir @workdir do
+        @stdin, @stdout, @wait_thr = Open3.popen2e "#{@java} -jar #{@jar} nogui"
+      end
+      @reader = Thread.new(@stdout) do |stream|
+        until stream.closed?
+          begin
+            line = stream.readline
+            @queue << line
+            log_server line
+            if line =~ /\<([^>]+)\> (.*)$/
+              log_message "<#{$1}> #{$2}"
+            end
+          rescue EOFError
+            break
+          end
+        end
+        Thread.main.raise ServerShutdown
+      end
+      wait_for_line /Done \(.*?\)!/
+      if @ops
+        @ops.each {|op| command "op #{op}"}
+      end
+    end
+
+    def command(cmd)
+      log_command cmd
+      @stdin.write("#{cmd}#{$/}")
+    end
+
+    def say(message)
+      log_message "[Server] #{message}"
+      @stdin.write("say #{message}#{$/}")
+    end
+
+    def on_line(match, &block)
+      @matchers << [match, block]
+    end
+
+    def on_message(match, user=nil, &block)
+      @message_matchers << [match, user, block]
+    end
+
+    def stop
+      unless @stopping
+        @matchers = []
+        command "stop"
+        @stdin.close
+        @stopping = true
+      end
+      join
+    end
+
+    def loop!
+      wait_for_line nil
+    rescue ServerShutdown
+      log_status "Server stopped."
+      join
+    end
+
+    private
+    def wait_for_line(match)
+      begin
+        line = @queue.pop
+        @matchers.each do |m, block|
+          block.call(line) if m === line
+        end
+        if line =~ /\<([^>]+)\> (.*)$/
+          user, message = $1, $2
+          @message_matchers.each do |m, u, block|
+            if !u or u == user or u === user
+              if m === message
+                block.call(message, user)
+              end
+            end
+          end
+        end
+      end until match and match === line
+      line
+    end
+
+    def join
+      @wait_thr.join
+      @reader.join
+    end
+  end
+end

data/lib/mcblocky/version.rb

@@ -0,0 +1,3 @@
+module McBlocky
+  VERSION = "0.1.0"
+end

data/lib/mcblocky.rb

@@ -0,0 +1,23 @@
+module McBlocky
+  def self.reload!
+    McBlocky.send(:remove_const, :DSL) if defined? McBlocky::DSL
+    McBlocky.send(:remove_const, :Context) if defined? McBlocky::Context
+    McBlocky.send(:remove_const, :Executor) if defined? McBlocky::Executor
+    load File.expand_path('mcblocky/dsl.rb', File.dirname(__FILE__))
+    load File.expand_path('mcblocky/context.rb', File.dirname(__FILE__))
+    load File.expand_path('mcblocky/executor.rb', File.dirname(__FILE__))
+  end
+end
+
+# non-reloadable
+require "mcblocky/location"
+require "mcblocky/config"
+require "mcblocky/listener"
+require "mcblocky/server"
+require "mcblocky/version"
+require "mcblocky/cli"
+
+# reloadable
+require "mcblocky/context"
+require "mcblocky/dsl"
+require "mcblocky/executor"

data/mcblocky.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mcblocky/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mcblocky"
+  spec.version       = McBlocky::VERSION
+  spec.version       = "#{spec.version}-alpha-#{ENV['TRAVIS_BUILD_NUMBER']}" if ENV['TRAVIS']
+  spec.authors       = ["Michael Limiero"]
+  spec.email         = ["mike5713@gmail.com"]
+
+  spec.summary       = %q{Minecraft command blocks as Ruby code}
+  spec.description   = %q{McBlocky is a Ruby DSL for creating Minecraft command block contraptions and maps.}
+  spec.homepage      = "https://github.com/DeltaWhy/mcblocky"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+
+  spec.add_runtime_dependency "thor", "~> 0.19"
+  spec.add_runtime_dependency "listen", "~> 3.0"
+end