alchemist-server 0.0.1

data/lib/alchemist-server/version.rb

@@ -0,0 +1,8 @@
+module Alchemist
+  module Server
+    if defined? VERSION
+      raise "OMG"
+    end
+    VERSION = "0.0.1"
+  end
+end

data/lib/alchemist-server/world.rb

@@ -0,0 +1,206 @@
+module Alchemist
+  class World
+    include Record
+    LOOK_RANGE = 10
+    record_attr :avatars,
+                :formulas,
+                :geography,
+                :elements,
+                :locked
+
+    def to_s
+      (avatars.to_a.map(&:to_s) + [geography]).join("\n")
+    end
+
+    def new_avatar(name)
+      a = Avatar.new name: name,
+                     x: 0,
+                     y: 0,
+                     inventory: "",
+                     messages: Hamster.hash
+
+      if !avatars.include? a
+        update avatars: avatars | [a]
+      end
+    end
+
+    def nearby_avatar_names(name)
+      nearby_avatars(avatar(name)).map &:name
+    end
+
+    def nearby_avatars(a)
+      avatars.select do |avatar|
+        avatar.near? a.location, LOOK_RANGE
+      end
+    end
+
+    def lock
+      raise "The world is already locked" if locked
+      update locked: true
+    end
+
+    def validate_element_symbol!(symbol)
+      if !Glyphs.strings.include? symbol
+        raise "#{symbol} is not a valid element symbol"
+      end
+    end
+
+    LOCKED_MESSAGE = "New basic elements can no longer be created. Try creating a compound instead"
+    def new_element(char, name)
+      raise LOCKED_MESSAGE if locked
+      validate_element_symbol! char
+
+      e = Element.new symbol: char, name: name, basic: true
+
+      update elements: elements.put(char, e)
+    end
+
+    def formulate(avatar_name, elem_1, elem_2, novel_elem, name)
+      validate_element_symbol! novel_elem
+
+      if formulas[novel_elem]
+        raise "There is already a formula for #{novel_elem}"
+
+      elsif elements[novel_elem]
+        raise "#{novel_elem} is a basic element!"
+
+      else
+        f = Formula.new elem_1, elem_2, novel_elem
+        e = Element.new symbol: novel_elem,
+                        name: name,
+                        basic: false
+
+        w = update formulas: formulas.put(novel_elem, f),
+                   elements: elements.put(novel_elem, e)
+
+        w.forge(avatar_name, elem_1, elem_2, novel_elem)
+      end
+    end
+
+    def forge(avatar_name, elem_1, elem_2, result)
+      a = avatar avatar_name
+
+      if !a.has?(elem_1, elem_2)
+        raise "#{avatar_name} doesn't have the required elements"
+      end
+
+      f = Formula.new elem_1, elem_2, result
+
+      if formulas[result] == f
+        a_temp = a.remove_from_inventory elem_1, elem_2
+        a_prime = a_temp.add_to_inventory result
+
+        update avatars: avatars - [a] + [a_prime]
+      else
+        raise "Incorrect formula for #{result}"
+      end
+    end
+
+    def avatar(name)
+      avatars.detect { |a| a.name == name } ||
+      raise("#{name} isn't in the world")
+    end
+
+    def at(avatar_name)
+      a = avatar(avatar_name)
+      geography.at a.x, a.y
+    end
+
+    def look(avatar_name)
+      a = avatar(avatar_name)
+      geography.string_around a.x, a.y, LOOK_RANGE
+    end
+
+    def take(avatar_name)
+      a = avatar(avatar_name)
+
+      resource = geography.at a.x, a.y
+      new_a = a.add_to_inventory resource
+      new_g = geography.take a.x, a.y
+
+      update avatars: avatars - [a] + [new_a],
+             geography: new_g
+    end
+
+    def put(avatar_name, c)
+      a = avatar(avatar_name)
+
+      if a.has? c
+        new_g = geography.put a.x, a.y, c
+        new_a = a.remove_from_inventory c
+
+        update avatars: avatars - [a] + [new_a],
+               geography: new_g
+      else
+        raise "#{avatar_name} doesn't have #{c}"
+      end
+    end
+
+    def create(avatar_name, c)
+      a = avatar(avatar_name)
+      new_a = a.add_to_inventory c
+
+      element = elements[c]
+
+      if element.nil?
+        raise "Unknown element: #{c}."
+      elsif !element.basic
+        raise "#{c} is not a basic element."
+      end
+
+      update avatars: avatars - [a] + [new_a]
+    end
+
+    def move(avatar_name, direction)
+      a = avatar(avatar_name)
+      a_prime = a.move direction
+
+      update avatars: avatars - [a] + [a_prime]
+    end
+
+    def put_message(avatar_name, key, message)
+      a = avatar(avatar_name)
+      a_prime = a.put_message key, message
+
+      update avatars: avatars - [a] + [a_prime]
+    end
+
+    def messages_for(avatar_name)
+      a = avatar(avatar_name)
+      messengers = nearby_avatars a
+
+      messengers.sort_by(&:name).map do |m|
+        { m.name => m.message_list }
+      end.reduce({}, :merge)
+    end
+
+    def location(avatar_name)
+      a = avatar avatar_name
+      [a.x, a.y]
+    end
+
+    def dimensions
+      geography.dimensions
+    end
+
+    def basic_elements
+      elements.values.select(&:basic?)
+    end
+
+    def compound_elements
+      elements.values.reject(&:basic?)
+    end
+
+    def element(symbol)
+      elements[symbol]
+    end
+
+    def self.genesis
+      World.new avatars: [],
+                formulas: Hamster.hash,
+                geography: Geography.new,
+                elements: Hamster.hash
+    end
+  end
+end
+

data/lib/alchemist-server/world_history.rb

@@ -0,0 +1,45 @@
+module Alchemist
+  class WorldHistory
+    attr_reader :world
+
+    def initialize(event, prior_history)
+      @event = event
+      @prior_history = prior_history
+
+      @world =
+        if @prior_history.nil?
+          World.genesis
+        else
+          outcome = @event.happen @prior_history
+          outcome.try(:new_world) || prior_world
+        end
+    end
+
+    def prior_world
+      @prior_history.try :world
+    end
+
+    def to_s
+      <<-str.strip
+#{@prior_history}
+
+#{@event}
+      str
+    end
+
+    def self.parse(string)
+      split_into_chronological_events(string).reduce(nil) do |history, event_string|
+        new Event.parse(event_string), history
+      end
+    end
+
+    def self.split_into_chronological_events(string)
+      string.split("\n\n").reject { |l| l =~ /^\s*$/ }
+    end
+
+    def self.genesis
+      new Event.genesis, nil
+    end
+  end
+end
+

data/script/alchemist-curses

@@ -0,0 +1,307 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH << "../lib"
+
+require 'bundler'
+Bundler.setup
+
+require 'alchemist-server'
+require 'ffi-ncurses'
+require 'alchemist-server/curses/item_window'
+require 'alchemist-server/curses/prompt_window'
+require 'alchemist-server/curses/glyph_window'
+require 'alchemist-server/curses/messages_window'
+require 'alchemist-server/curses/geography_window'
+
+host = ARGV[0] || 'localhost'
+port = (ARGV[1] || 7900).to_i
+
+def start(host, port)
+  EventMachine.run do
+    EventMachine.connect host, port, Handler
+  end
+end
+
+module Handler
+  include FFI::NCurses
+  include Alchemist::EventMachine::ClientProtocol
+
+  INVENTORY_LABEL = 'Inventory: '
+  INVENTORY_SIZE = 64
+
+  BASICS_LABEL = 'Basics: '
+  BASICS_SIZE = INVENTORY_SIZE
+
+  COMPOUNDS_LABEL = 'Compounds: '
+  COMPOUNDS_SIZE = INVENTORY_SIZE
+
+  AVATAR_COLOR_NUM = 1
+
+  def post_init
+    start_color
+    init_pair AVATAR_COLOR_NUM, Color::BLACK, Color::GREEN
+
+    @border_win = newwin 22, 45, 0, 0
+    @geo_win = Alchemist::Curses::GeographyWindow.new(
+      1, 1, AVATAR_COLOR_NUM)
+
+    @location_win = newwin 1, 45, 23, 0
+
+    @prompt_win = Alchemist::Curses::PromptWindow.new(
+      24, 0, 80)
+
+    @inventory_win = Alchemist::Curses::ItemWindow.new(
+      INVENTORY_LABEL,
+      INVENTORY_SIZE,
+      25,
+      0
+    )
+
+    @basics_win = Alchemist::Curses::ItemWindow.new(
+      BASICS_LABEL,
+      BASICS_SIZE,
+      26,
+      0
+    )
+
+    @compounds_win = Alchemist::Curses::ItemWindow.new(
+      COMPOUNDS_LABEL,
+      COMPOUNDS_SIZE,
+      27,
+      0
+    )
+
+    @error_win = newwin 1, 80, 28, 0
+    @glyph_win = Alchemist::Curses::GlyphWindow.new 0, 46
+
+    @messages_win = Alchemist::Curses::MessagesWindow.new(
+      10, 80, 29, 0
+    )
+  end
+
+  def item_hover(item)
+    describe item
+  end
+
+  def draw_geo_border
+    lr = '|'.ord
+    tb = '-'.ord
+    c = '+'.ord
+
+    wborder @border_win,lr,lr,tb,tb,c,c,c,c
+    wrefresh @border_win
+  end
+
+  def handle_see(data)
+    if @location
+      @geo_win.update @location, data
+    end
+  end
+
+  def handle_location(data)
+    x, y = data.split(/\s+/).map &:to_i
+    @location = [x, y]
+    draw_location *@location
+    @geo_win.update_avatar @name, *@location
+  end
+
+  def draw_location(x, y)
+    wclear @location_win
+    wmove @location_win, 0, 0
+    wprintw @location_win, "Location: #{x},#{y}"
+    wrefresh @location_win
+  end
+
+  def handle_inventory(data)
+    @inventory_win.update data
+    move_to_avatar_position
+  end
+
+  def handle_basics(data)
+    @basics_win.update data
+    move_to_avatar_position
+  end
+
+  def handle_compounds(data)
+    @compounds_win.update data
+    move_to_avatar_position
+  end
+
+  def handle_messages(data)
+    @messages_win.update data.split("\n")
+    move_to_avatar_position
+  end
+
+  def move_to_avatar_position
+    @geo_win.move_to_avatar_position
+  end
+
+  def handle_element(message)
+    draw_error message.pad_to_unicode_monospace
+  end
+
+  def element(message)
+    draw_error message.pad_to_unicode_monospace
+  end
+
+  def handle_error(error)
+    draw_error error
+  end
+
+  def draw_error(error)
+    wmove @error_win, 0, 0
+    wprintw @error_win, "Last error: "
+    wprintw @error_win, error
+    wrefresh @error_win
+    move_to_avatar_position
+  end
+
+  def handle_avatars(data)
+    locations = data.each_line.map do |line|
+      name, x, y = line.split /\s+/
+      { name => [x.to_i,y.to_i] }
+    end
+
+    @geo_win.update_avatars locations.reduce :merge
+  end
+
+  def handle_welcome
+    EM.defer(-> { @prompt_win.ask "Enter your name" },
+             -> name do
+      @name = name
+      login name
+    end)
+  end
+
+  def handle_hello
+    printw "Appearing...\n"
+    refresh
+    appear
+  end
+
+  def handle_appeared
+    draw_geo_border
+    who
+    request_location
+    look
+    request_inventory
+    request_basics
+    request_compounds
+    read
+    action_loop
+  end
+
+  def act(char)
+    case char
+    when KEY_LEFT then move_action "west"
+    when KEY_RIGHT then move_action "east"
+    when KEY_UP then move_action "north"
+    when KEY_DOWN then move_action "south"
+    when 't'.ord then take_action
+    when 'p'.ord then put_action
+    when 'c'.ord then create_action
+    when 'e'.ord then element_action
+    when 'f'.ord then forge_action
+    when 'F'.ord then formulate_action
+    when 'm'.ord then post_message_action
+    when 'r'.ord then read
+    when 'd'.ord then describe_action
+    end
+  end
+
+  def move_action(direction)
+    move direction
+    look
+  end
+
+  def put_action
+    if element = @inventory_win.have_user_select
+      put element
+    end
+  end
+
+  def describe_action
+    if element = @inventory_win.have_user_select
+      describe element
+    end
+  end
+
+  def create_action
+    if element = @basics_win.have_user_select
+      create element
+    end
+  end
+
+  def element_action
+    if symbol = @glyph_win.have_user_select
+      name = @prompt_win.ask "New Element Name"
+      element symbol, name
+      request_basics
+    end
+  end
+
+  def forge_action
+    if (ingred_1 = @inventory_win.have_user_select) &&
+       (ingred_2 = @inventory_win.have_user_select) &&
+       (result = @compounds_win.have_user_select)
+      forge ingred_1, ingred_2, result
+    end
+  end
+
+  def formulate_action
+    if (ingred_1 = @inventory_win.have_user_select) &&
+       (ingred_2 = @inventory_win.have_user_select) &&
+       (result = @glyph_win.have_user_select)
+      name = @prompt_win.ask "Compound Name"
+      formulate ingred_1, ingred_2, result, name
+      request_compounds
+    end
+  end
+
+  def post_message_action
+    if input = @prompt_win.ask("Message (# msg)")
+      num, message = input.split(' ',2)
+      message num, message
+      read
+    end
+  end
+
+  def take_action
+    take
+  end
+
+  def action_loop
+    EM.defer(-> { getch },
+             -> c do
+                act c
+                action_loop
+             end)
+  end
+end
+
+class UI
+  def initialize(handler)
+    @h = handler
+  end
+end
+
+begin
+  # tell the terminal to enter curses mode
+  FFI::NCurses.initscr
+  FFI::NCurses.noecho
+  FFI::NCurses.halfdelay 1
+
+  FFI::NCurses.printw "Connecting.... to #{host}:#{port}\n"
+
+  # causes changes to be displayed on the screen - maybe this means that NCurses
+  # uses front and back buffers for drawing?
+  FFI::NCurses.refresh
+  FFI::NCurses.keypad FFI::NCurses.stdscr, true
+
+  start host, port
+ensure
+  # returns back to regular console mode
+  FFI::NCurses.endwin
+end
+