alchemist-server 0.0.1

data/lib/alchemist-server/curses/item_window.rb

@@ -0,0 +1,59 @@
+module Alchemist
+  module Curses
+    class ItemWindow
+      include FFI::NCurses
+
+      def initialize(label, size, line, column)
+        @label = label
+        @width = label.length + size * 2
+        @win = newwin 1, @width, line, column
+        @items = ""
+      end
+
+      def update(items)
+        @items = items.force_encoding Encoding::UTF_8
+        draw
+      end
+
+      def draw
+        wclear @win
+        wprintw @win, "#{@label}#{@items.pad_to_unicode_monospace}"
+        wrefresh @win
+      end
+
+      def have_user_select
+        wmove @win, 0, @label.length
+        wrefresh @win
+
+        while (c = getch) != KEY_RETURN
+          case c
+          when KEY_LEFT
+            y,x = getyx @win
+            new_x = [x - 2, @label.length].max
+            wmove @win, 0, new_x
+            wrefresh @win
+
+          when KEY_RIGHT
+            y,x = getyx @win
+            new_x = [x + 2, @width - 1].min
+            wmove @win, 0, new_x
+            wrefresh @win
+
+          when KEY_ESCAPE
+            return nil
+          end
+        end
+
+        y,x = getyx @win
+
+        item_at x
+      end
+
+      def item_at(x)
+        inv_index = (x - @label.length) / 2
+        @items[inv_index]
+      end
+    end
+  end
+end
+

data/lib/alchemist-server/curses/messages_window.rb

@@ -0,0 +1,43 @@
+module Alchemist
+  module Curses
+    class MessagesWindow
+      include FFI::NCurses
+
+      def initialize(height, width, line, col)
+        @height = height
+        @width = width
+
+        @offset = 0
+        @messages = []
+
+        @win = newwin height, width, line, col
+      end
+
+      def draw
+        wmove @win, 0, 0
+        wclear @win
+        wprintw @win, messages_to_show.join("\n")
+        wrefresh @win
+      end
+
+      def messages_to_show
+        @messages[@offset,@height] || []
+      end
+
+      def update(messages)
+        @messages = messages
+        draw
+      end
+
+      def scroll_up
+        @offset = [@offset-1, 0].max
+        draw
+      end
+
+      def scroll_down
+        @offset = [@offset+1, @messages.length - height].min
+        draw
+      end
+    end
+  end
+end

data/lib/alchemist-server/curses/prompt_window.rb

@@ -0,0 +1,35 @@
+module Alchemist
+  module Curses
+    class PromptWindow
+      include FFI::NCurses
+
+      def initialize(line, col, width)
+        @win = newwin 1, width, line, col
+      end
+
+      def ask(label)
+        wclear @win
+        wmove @win, 0, 0
+        wprintw @win, label
+        wprintw @win, ': '
+        wrefresh @win
+
+        answer = ''
+
+        while (c = wgetch @win) != "\n".ord
+          if c > 0
+            answer << c
+            wprintw @win, (''<<c)
+          end
+
+          wrefresh @win
+        end
+
+        wclear @win
+
+        answer.strip
+      end
+    end
+  end
+end
+

data/lib/alchemist-server/direction.rb

@@ -0,0 +1,28 @@
+module Alchemist
+  module Direction
+    module North
+      def self.move_from(x, y)
+        [x, y - 1]
+      end
+    end
+
+    module South
+      def self.move_from(x, y)
+        [x, y + 1]
+      end
+    end
+
+    module East
+      def self.move_from(x, y)
+        [x + 1, y]
+      end
+    end
+
+    module West
+      def self.move_from(x, y)
+        [x - 1, y]
+      end
+    end
+  end
+end
+

data/lib/alchemist-server/element.rb

@@ -0,0 +1,14 @@
+module Alchemist
+  class Element
+    include Record
+    record_attr :symbol, :name, :basic
+
+    def basic?
+      basic
+    end
+
+    def hex_code
+      "0x#{symbol.ord.to_s(16)}"
+    end
+  end
+end

data/lib/alchemist-server/event.rb

@@ -0,0 +1,43 @@
+module Alchemist
+  class Event
+    attr_reader :command_string
+
+    def initialize(command_string, time)
+      @command_string = command_string
+      @time = time
+    end
+
+    def happen(history)
+      avatar_name, command, *args = @command_string.split /\s+/
+
+      if command_mod = COMMANDS.detect { |c| match_command? command, c }
+        command_mod.run avatar_name, history, *args
+      else
+        Outcome.new response: "error Unknown Command: #{command}"
+      end
+    end
+
+    def to_s
+      <<-str
+#{@command_string}
+#{@time}
+      str
+    end
+
+    protected
+
+    def match_command?(command_name, command)
+      command_name =~ /^#{command.pattern}/
+    end
+
+    def self.parse(string)
+      command_string, time, world_string = string.split("\n",3)
+      new command_string, Time.parse(time)
+    end
+
+    def self.genesis
+      new 'genesis', Time.now
+    end
+  end
+end
+

data/lib/alchemist-server/formula.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Alchemist
+  class Formula
+    attr_reader :elem_1, :elem_2, :result
+
+    def initialize(elem_1, elem_2, result)
+      @elem_1 = elem_1
+      @elem_2 = elem_2
+      @result = result
+    end
+
+    def to_s
+      "⨍ #{@elem_1}#{@elem_2}#{@result}"
+    end
+
+    def ==(other)
+      other.class == self.class &&
+      other.elem_1 == elem_1 &&
+      other.elem_2 == elem_2 &&
+      other.result == result
+    end
+  end
+end
+

data/lib/alchemist-server/geography.rb

@@ -0,0 +1,111 @@
+module Alchemist
+  class Geography
+    def initialize(locations = {})
+      @locations = case locations
+                   when Hamster::Hash then locations
+                   else Hamster.hash locations
+                   end
+    end
+
+    def at(x,y)
+      locations[Loc[x,y]]
+    end
+
+    def take(x,y)
+      Geography.new locations.delete(Loc[x,y])
+    end
+
+    def put(x,y,c)
+      loc = Loc[x,y]
+
+      if locations.key? loc
+        raise "#{locations[loc]} is already at #{x},#{y}"
+      end
+
+      Geography.new locations.put(loc, c[0..1])
+    end
+
+    def string_around(x,y,range)
+      string_within x - range,
+                    y - range,
+                    x + range,
+                    y + range
+    end
+
+    def to_s
+      (min_x, min_y), (max_x, max_y) = dimensions
+      string_within min_x, min_y, max_x, max_y
+    end
+
+    def string_within(min_x, min_y, max_x, max_y)
+      if min_x && min_y && max_x && max_y
+        (min_y..max_y).map do |y|
+          (min_x..max_x).map do |x|
+            at(x, y) || ' '
+          end.join('')
+        end.join("\n")
+      else
+        ''
+      end
+    end
+
+
+    def dimensions
+      points = locations.keys
+      xs,ys = points.map(&:x), points.map(&:y)
+
+      [[xs.min, ys.min],[xs.max,ys.max]]
+    end
+
+    private
+
+    def locations
+      @locations
+    end
+
+    def offset(x,y)
+      w,h = dimensions
+      y*(w + 1) + x
+    end
+
+    class Loc
+      attr_reader :x, :y
+
+      def self.[](*args)
+        new *args
+      end
+
+      def initialize(x,y)
+        @x = x
+        @y = y
+      end
+
+      def hash
+        (@x.hash * 31) + @y.hash
+      end
+
+      def within?(min, max)
+        min.x <= x && x <= max.x &&
+        min.y <= y && y <= max.y
+      end
+
+      def distance(loc)
+        [
+          (loc.x - x).abs,
+          (loc.y - y).abs
+        ].max
+      end
+
+      def ==(other)
+        other.class == self.class &&
+        other.x == x &&
+        other.y == y
+      end
+
+      def eql?(other)
+        self == other
+      end
+    end
+  end
+end
+

data/lib/alchemist-server/outcome.rb

@@ -0,0 +1,12 @@
+module Alchemist
+  class Outcome
+    include Record
+    include Enumerable
+
+    record_attr :response,
+                :new_world,
+                :new_history,
+                :nearby_avatar_command
+  end
+end
+

data/lib/alchemist-server/record.rb

@@ -0,0 +1,51 @@
+module Alchemist
+  module Record
+    def self.included(mod)
+      mod.extend ClassMethods
+    end
+
+    def initialize(attrs = {})
+      @attrs = Record.hamsterize(attrs).slice(*attr_names)
+    end
+
+    def update(attr_changes)
+      self.class.new @attrs.merge(Record.hamsterize(attr_changes))
+    end
+
+    def read(attr)
+      @attrs[attr]
+    end
+
+    def attr_names
+      self.class.attr_names
+    end
+
+    def self.hamsterize(hash)
+      case hash
+      when Hamster::Hash then hash
+      else Hamster.hash hash
+      end
+    end
+
+    module ClassMethods
+      def attr_names
+        @attr_names ||= []
+      end
+
+      def attr_names=(attrs)
+        @attr_names = attrs
+      end
+
+      def record_attr(*attrs)
+        attrs.each do |attr|
+          class_eval %{
+            def #{attr}
+              read :#{attr}
+            end
+          }
+        end
+        self.attr_names += attrs
+      end
+    end
+  end
+end

data/lib/alchemist-server/server_handler.rb

@@ -0,0 +1,143 @@
+module Alchemist
+  module ServerHandler
+    def self.new(world_file)
+      puts "Loading history...."
+      history = Alchemist::Server.load_history world_file
+
+      Module.new do
+        include Methods
+
+        @world_file = world_file
+        @history = history
+        @connections = []
+
+        class <<self
+          attr_reader :world_file
+          attr_accessor :history
+          attr_accessor :connections
+        end
+
+        def self.included(mod)
+          mod.instance_variable_set :@state, self
+          def mod.state; @state; end
+        end
+
+        def world_file
+          self.class.state.world_file
+        end
+
+        def history
+          self.class.state.history
+        end
+
+        def history=(h)
+          self.class.state.history = h
+        end
+
+        def connections
+          self.class.state.connections
+        end
+      end
+    end
+
+    module Methods
+      include ::EventMachine::Protocols::LineProtocol
+
+      attr_reader :name
+
+      def post_init
+        connections << self
+        send_line "Welcome alchemical friend. What is your name?"
+      end
+
+      def unbind
+        connections.delete self
+      end
+
+      def receive_line(line)
+        t = Benchmark.realtime do
+          response = process_line line
+
+          if response
+            send_line response
+          end
+        end
+
+        puts "#{Time.now} #{line.split(' ').first} #{(t*1000).round}"
+      end
+
+      def process_line(line)
+        if name
+          command = "#{name} #{line.chomp}"
+          outcome = Alchemist::Server.run_append command,
+                                                 world_file,
+                                                 history
+
+          self.history = outcome.new_history if outcome.new_history
+
+          if command = outcome.nearby_avatar_command
+            run_command_nearby command
+          end
+
+          outcome.response
+        else
+          possible_name = line.strip.split(' ').first
+
+          if possible_name && possible_name.length > 0
+            @name = possible_name
+            "hello #{name}"
+          else
+            "Please tell me your name."
+          end
+        end
+      rescue => e
+        show_error e
+        "error #{e}"
+      end
+
+      def run_command_nearby(command)
+        new_nearby = history.world.nearby_avatar_names name
+        old_nearby = begin
+                       history.prior_world.try :nearby_avatar_names, name
+                     rescue
+                       # bail out if user wasn't in prior world
+                       []
+                     end
+
+        nearby = new_nearby | (old_nearby || [])
+
+        connections.select do |c|
+          begin
+            if nearby.include? c.name
+              c.run_unrecorded_command command
+            end
+          rescue => e
+            show_error e
+          end
+        end
+      end
+
+      def show_error(e)
+        $stderr.puts "#{e.class}: #{e.message}"
+        $stderr.puts e.backtrace
+      end
+
+      def run_unrecorded_command(command)
+        outcome = command.run name, history
+
+        if r = outcome.response
+          send_line r
+        end
+      end
+
+      def send_line(data)
+        send_data data
+
+        if data[-1] != "\n"
+          send_data "\n"
+        end
+      end
+    end
+  end
+end
+