MonkeyEngine 1.0.0

data/lib/MonkeyActions.rb

@@ -0,0 +1,6 @@
+require_relative 'MonkeyAction/monkey_action_dead'
+require_relative 'MonkeyAction/monkey_action_eat'
+require_relative 'MonkeyAction/monkey_action_pause'
+require_relative 'MonkeyAction/monkey_action_sleep'
+require_relative 'MonkeyAction/monkey_action_type'
+require_relative 'MonkeyAction/monkey_action_wake'

data/lib/MonkeyEngine.rb

@@ -0,0 +1 @@
+require_relative 'MonkeyEngine/monkey_engine'

data/lib/MonkeyEngine/action_rules.rb

@@ -0,0 +1,111 @@
+require 'time'
+require 'singleton'
+
+require 'MonkeyActions'
+require 'MonkeyKeyboardEnUs'
+
+# Handles monkey action rules.
+class ActionRules
+  include Singleton
+
+# Retrieves tne next action for the monkey
+#
+# @param [monkey] the monkey whose next action is to be retrieved
+# @return [MonkeyAction] the next monkey action
+  def get_next_action(monkey)
+    raise MonkeyEngine::Exceptions::InvalidOperationException.new \
+        "The action [#{monkey.action.class.name}] for Monkey [#{monkey.monkey_symbol}] must be completed before calling get_next_action" \
+          unless monkey.action.nil? || monkey.action.action_completed?
+
+    # current_action = monkey.action
+
+    # If the monkey is sleeping, or first action, wake him up.
+    return MonkeyActionWake.new(monkey) if monkey.action.nil? || monkey.action.is_a?(MonkeyActionSleep)
+
+    return get_next_action_eval(monkey) unless nil
+
+    # Nothing else interesting, monkey takes a breather...
+    # MonkeyActionPause.new(monkey, Random.new.rand(MonkeyActionPause::VALID_VALUES))
+    MonkeyActionPause.new(monkey, 5)
+  end
+
+  def get_next_action_eval(monkey)
+    # TODO: Add logic to determine next logical action.
+
+    keyboard_input = MonkeyEngine::MonkeyKeyboardEnUs.instance.get_keyboard_input
+
+    return MonkeyActionType.new monkey, keyboard_input
+  end
+
+  # Evaluates an action and sets it to completed if the criteria for completion is met.
+  def action_eval!(action)
+    raise MonkeyEngine::Exceptions::NilArgumentException.new "The [action] to be evaluated cannot be nil" \
+        if action.nil?
+
+    raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "The [action] is not the correct type" \
+        unless action.is_a? Action
+
+    action_eval_eat(action) if action.is_a?(MonkeyActionEat)
+    action_eval_pause(action) if action.is_a?(MonkeyActionPause)
+    action_eval_sleep(action) if action.is_a?(MonkeyActionSleep)
+    action_eval_type(action) if action.is_a?(MonkeyActionType)
+    action_eval_wake(action) if action.is_a?(MonkeyActionWake)
+
+    # If we don't specifically handle the action, just let it pass through - Action#action_completed will
+    # be set elsewhere.
+    action.action_completed?
+  end
+
+  private
+
+  # Action evaluation methods
+
+  def action_eval_eat(action)
+    raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "The [action] is not the correct type" \
+        unless action.is_a? MonkeyActionEat
+
+    action_eval_timed_action action
+  end
+
+  def action_eval_pause(action)
+    raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "The [action] is not the correct type" \
+        unless action.is_a? MonkeyActionPause
+
+    action_eval_timed_action action
+  end
+
+  def action_eval_sleep(action)
+    raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "The [action] is not the correct type" \
+        unless action.is_a? MonkeyActionSleep
+
+    action_eval_timed_action action
+  end
+
+  def action_eval_type(action)
+    raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "The [action] is not the correct type" \
+        unless action.is_a? MonkeyActionType
+
+    # TODO: How do I evaluate this?
+
+    action
+  end
+
+  def action_eval_wake(action)
+    raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "The [action] is not the correct type" \
+        unless action.is_a? MonkeyActionWake
+
+    action.action_completed = true
+
+    action
+  end
+
+  def action_eval_timed_action(action)
+    raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "The [action] is not the correct type" \
+        unless action.is_a? MonkeyTimedAction
+
+    action.action_completed = true if action.action_time_of_completion <= Time.now
+
+    action
+  end
+
+end

data/lib/MonkeyEngine/exceptions.rb

@@ -0,0 +1,21 @@
+require 'test/unit/assertions'
+
+module MonkeyEngine
+  module Exceptions
+    class InvalidArgumentValueException < ArgumentError;
+    end
+
+    class InvalidArgumentTypeException < ArgumentError;
+    end
+
+    class NilArgumentException < ArgumentError;
+    end
+
+    # The object must be unique.
+    class UniqueObjectException < ArgumentError;
+    end
+
+    class InvalidOperationException < ArgumentError;
+    end
+  end
+end

data/lib/MonkeyEngine/monkey_engine.rb

@@ -0,0 +1,53 @@
+require 'observer'
+require 'singleton'
+require 'time'
+
+require 'MonkeyActions'
+require_relative 'action_rules'
+
+module MonkeyEngine
+
+  # Assigns, executes and evaluates actions.
+  class Engine
+    include Singleton
+    include Observable
+
+    private
+    def initialize
+    end
+
+    public
+
+    # Evaluates whether or not the action is completed.
+    def action_eval!(action)
+      ActionRules.instance.action_eval! action
+    end
+
+    def do_action(action)
+      raise MonkeyEngine::Exceptions::InvalidOperationException.new \
+        "The action [#{action.class.name}] for Monkey [#{action.monkey.monkey_symbol}] is already completed" if action.action_completed?
+
+      do_action_type(action) if action.is_a? MonkeyActionType
+
+      # TODO: Update database for monkey with action detail
+      # TODO: Call observer to notify of action update.
+      # TODO: Set action.action_completed to true if the action is completed.
+
+      action.action_completed?
+    end
+
+    def do_action_type(action)
+      action.action_completed = true
+    end
+
+    # Returns a new action.
+    def new_action(monkey)
+      raise MonkeyEngine::Exceptions::InvalidOperationException.new \
+        "The action [#{monkey.action.class.name}] for Monkey [#{monkey.monkey_symbol}] must be completed before calling new_action" \
+          unless monkey.action.nil? || monkey.action.action_completed?
+
+      return ActionRules.instance.get_next_action monkey
+    end
+
+  end
+end

data/lib/MonkeyEngine/version.rb

@@ -0,0 +1,3 @@
+module MonkeyEngine
+  VERSION = "1.0.0"
+end

data/lib/MonkeyFactory.rb

@@ -0,0 +1 @@
+require_relative 'MonkeyFactory/monkey_factory'

data/lib/MonkeyFactory/monkey_factory.rb

@@ -0,0 +1,14 @@
+require 'Monkey'
+
+module MonkeyFactory
+
+  class << self
+
+    public
+    def create(monkey_symbol)
+      # Call the protected constructor - monkeys can only be created
+      # via the MonkeyFactory.
+      Monkey.send(:new, monkey_symbol)
+    end
+  end
+end

data/lib/MonkeyKeyboard/keyboard_char.rb

@@ -0,0 +1,10 @@
+# Represents a keyboard character.
+class KeyboardChar
+
+  attr_reader :char
+
+  def initialize(char)
+    @char = char
+    self
+  end
+end

data/lib/MonkeyKeyboard/keyboard_input.rb

@@ -0,0 +1,14 @@
+# Represents keyboard input.
+class KeyboardInput
+
+  attr_accessor :is_word, :input
+
+  def initialize
+    @is_word = false
+    @input = Array.new
+  end
+
+  def input_to_s
+    @input.join.to_s
+  end
+end

data/lib/MonkeyKeyboard/keyboard_key.rb

@@ -0,0 +1,26 @@
+require_relative 'keyboard_char'
+
+# Represents a keyboard key.
+class KeyboardKey
+  attr_reader :keyboard_char, :keyboard_shift_char, :keyboard_key_section, :keyboard_key_weight
+
+  def initialize(keyboard_char, keyboard_shift_char, keyboard_key_section, keyboard_key_weight)
+    # TODO: Check keyboard_char is_a? KeyboardChar
+    # TODO: Check keyboard_shift_char is_a? KeyboardChar
+    # TODO: Check keyboard_key_section is :left or :right
+
+    @keyboard_char = keyboard_char
+    @keyboard_shift_char = keyboard_shift_char
+    @keyboard_key_section = keyboard_key_section
+    @keyboard_key_weight = keyboard_key_weight
+  end
+
+  def self.make_key(char, shift_char, keyboard_key_section, keyboard_key_weight)
+    # TODO: Check keyboard_key_section is :left or :right
+
+    keyboard_char = KeyboardChar.new char
+    keyboard_shift_char = KeyboardChar.new shift_char
+
+    KeyboardKey.new keyboard_char, keyboard_shift_char, keyboard_key_section, keyboard_key_weight
+  end
+end

data/lib/MonkeyKeyboard/keyboard_key_evaluator.rb

@@ -0,0 +1,25 @@
+class KeyboardKeyEvaluator
+  def initialize
+    @shift_on = false
+    @caps_on = false
+  end
+
+  def get_char(keyboard_key)
+    @shift_on = !@shift_on if keyboard_key.keyboard_char.char == :shift
+    @caps_on = !@shift_on if keyboard_key.keyboard_char.char == :caps
+
+    return nil if keyboard_key.keyboard_char.char.is_a? Symbol
+
+    if @shift_on
+      return keyboard_key.keyboard_shift_char.char
+    end
+
+    char = keyboard_key.keyboard_char.char
+
+    if @caps_on
+      return char.upcase
+    end
+
+    char
+  end
+end

data/lib/MonkeyKeyboard/monkey_keyboard_en_us.rb

@@ -0,0 +1,137 @@
+require 'singleton'
+require 'LittleWeasel'
+
+require_relative 'keyboard_char'
+require_relative 'keyboard_key'
+require_relative 'keyboard_input'
+require_relative 'keyboard_key_evaluator'
+
+
+module MonkeyEngine
+
+  class MonkeyKeyboardEnUs
+    include Singleton
+
+    attr_reader :keys, :left_keys, :right_keys
+
+    def initialize
+
+      @keys = [
+          # Row 1 of 5
+          KeyboardKey::make_key('`', '~', :left, 1),
+          KeyboardKey::make_key('1', '!', :left, 1),
+          KeyboardKey::make_key('2', '@', :left, 1),
+          KeyboardKey::make_key('3', '#', :left, 1),
+          KeyboardKey::make_key('4', '$', :left, 1),
+          KeyboardKey::make_key('5', '%', :left, 1),
+          KeyboardKey::make_key('6', '^', :left, 1),
+          KeyboardKey::make_key('7', '&', :right, 1),
+          KeyboardKey::make_key('8', '*', :right, 1),
+          KeyboardKey::make_key('9', '(', :right, 1),
+          KeyboardKey::make_key('0', ')', :right, 1),
+          KeyboardKey::make_key('-', '_', :right, 1),
+          KeyboardKey::make_key('=', '+', :right, 1),
+          KeyboardKey::make_key(:del, :del, :right, 1),
+
+          # Row 2 of 5
+          KeyboardKey::make_key(:tab, :tab, :left, 2),
+          KeyboardKey::make_key('q', 'Q', :left, 1),
+          KeyboardKey::make_key('w', 'W', :left, 1),
+          KeyboardKey::make_key('e', 'E', :left, 1),
+          KeyboardKey::make_key('r', 'R', :left, 1),
+          KeyboardKey::make_key('t', 'T', :left, 1),
+          KeyboardKey::make_key('y', 'Y', :left, 1),
+          KeyboardKey::make_key('u', 'U', :right, 1),
+          KeyboardKey::make_key('i', 'I', :right, 1),
+          KeyboardKey::make_key('o', 'O', :right, 1),
+          KeyboardKey::make_key('p', 'P', :right, 1),
+          KeyboardKey::make_key('', '{', :right, 1),
+          KeyboardKey::make_key('', '}', :right, 1),
+          KeyboardKey::make_key('\\', '|', :right, 1),
+
+          # Row 3 of 5
+          KeyboardKey::make_key(:caps, :caps, :left, 3),
+          KeyboardKey::make_key('a', 'A', :left, 1),
+          KeyboardKey::make_key('s', 'S', :left, 1),
+          KeyboardKey::make_key('d', 'D', :left, 1),
+          KeyboardKey::make_key('f', 'F', :left, 1),
+          KeyboardKey::make_key('g', 'G', :left, 1),
+          KeyboardKey::make_key('h', 'H', :right, 1),
+          KeyboardKey::make_key('j', 'J', :right, 1),
+          KeyboardKey::make_key('k', 'K', :right, 1),
+          KeyboardKey::make_key('l', 'L', :right, 1),
+          KeyboardKey::make_key(';', ':', :right, 1),
+          KeyboardKey::make_key('\'', '"', :right, 1),
+          KeyboardKey::make_key(:enter, :enter, :right, 2),
+
+          # Row 4 of 5
+          KeyboardKey::make_key(:shift, :shift, :left, 5),
+          KeyboardKey::make_key('z', 'Z', :left, 1),
+          KeyboardKey::make_key('x', 'X', :left, 1),
+          KeyboardKey::make_key('c', 'C', :left, 1),
+          KeyboardKey::make_key('v', 'V', :left, 1),
+          KeyboardKey::make_key('b', 'B', :left, 1),
+          KeyboardKey::make_key('n', 'N', :right, 1),
+          KeyboardKey::make_key('m', 'M', :right, 1),
+          KeyboardKey::make_key(',', '<', :right, 1),
+          KeyboardKey::make_key('.', '>', :right, 1),
+          KeyboardKey::make_key('/', '?', :right, 1),
+          KeyboardKey::make_key(:shift, :shift, :right, 5),
+
+          # Row 5 of 5
+          KeyboardKey::make_key(:space, :space, :left, 2),
+          KeyboardKey::make_key(:space, :space, :right, 2)
+      ]
+
+      @left_keys = []
+      @right_keys = []
+
+      @keys.each { |key|
+        # Separate the keys on the left side of the keyboard...
+        key.keyboard_key_weight.times do
+          left_keys.push(key)
+        end if key.keyboard_key_section == :left
+
+        # Separate the keys on the right side of the keyboard...
+        key.keyboard_key_weight.times do
+          right_keys.push(key)
+        end if key.keyboard_key_section == :right
+      }
+
+      @keys.freeze
+      @keys_left.freeze
+      @keys_right.freeze
+    end
+
+    def get_keyboard_input
+      keyboard_input = KeyboardInput.new
+
+      left_keys = @left_keys
+      right_keys = @right_keys
+
+      keys = left_keys.zip(right_keys).flatten.compact.shuffle
+
+      keyboard_key_evaluator = KeyboardKeyEvaluator.new
+
+      # Take the keys until we hit a key that terminates a word...
+      keyboard_input.input = keys.take_while { |key|
+        !keyboard_char_ends_word?(key.keyboard_char.char)
+      }.collect { |key| keyboard_key_evaluator.get_char(key) }.compact
+
+      # Keep going until we get something...
+      keyboard_input = get_keyboard_input if keyboard_input.input.empty?
+
+      keyboard_input.is_word = LittleWeasel::Checker.instance.exists?(keyboard_input.input_to_s, 
+        exclude_alphabet: true, strip_whitespace: true, ignore_numeric: false, single_word_mode: true)
+
+      keyboard_input
+    end
+
+    # Returns true if the character causes a word termination.
+    def keyboard_char_ends_word?(char)
+      return char == :tab || char == :enter || char == :space || char == '.'
+    end
+
+  end
+
+end

data/lib/MonkeyKeyboardEnUs.rb

@@ -0,0 +1 @@
+require_relative 'MonkeyKeyboard/monkey_keyboard_en_us'