ruby-ai 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba65807dbe2e5d60896d8445d7059265ac0c7970
+  data.tar.gz: 3f2e8186d0d27868d408757a33a753684a4222c4
+SHA512:
+  metadata.gz: 93080045c2fefae29bd424cd5705797f8a2fd52d4b4b591e29f98307fc5b4320c36d5007b4904c07633177fd82b7aa908593a088bffadf99c6d801abc99b9f1d
+  data.tar.gz: 5127599601608ae2dcb761108d442eb28a18f70e75220aef592fd508af72a7d4bc59e05d30f6feef38b82271ec9990a89ae00af5f2e54739f84e9eb31544e2a2

data/README.md

@@ -0,0 +1,84 @@
+Ruby AI
+=========================
+This is my first gem. Feedback on best practices is very welcome.
+
+In this game, you write some basic AI to move the player block to the goal.
+
+Getting Started
+---------------------
+
+```bash
+$ gem install ruby-ai
+```
+
+Move to an empty directory of your choice.
+
+```bash
+$ ruby-ai init
+```
+
+The above command creates an ai.rb file and a levels directory within your current directory.
+
+```bash
+$ ruby-ai X
+```
+
+Substitute a level number for "X" to load that level. Seven pre-made levels are included, but you can easily add more (see below).
+
+Writing AI
+------------------
+
+Simply open the ai.rb file. On each update tick, the
+```ruby
+def level(num)
+  # your code here
+end
+```
+method will be called.
+
+You have two methods at your disposal:
+```ruby
+look(direction)
+```
+```ruby
+move(direction)
+```
+The usable directions are:
+```ruby
+:up, :down, :left, :right
+```
+
+The 'look' method will return a tile in the specified direction, or the tile at your current location if no direction in specified.
+The 'move' method will move you in the specified direction. Moving twice or hitting a wall will end the game.
+
+You can only see one space in each of the 4 available directions as you go. Each Tile object responds to:
+```ruby
+tile[:x] #=> the x coordinate of that tile
+tile[:y] #=> the y coordinate of that tile
+```
+The three Tile classes are Goal, Wall, Empty.
+
+Hint:
+```ruby
+look(:up).kind_of?(Wall)
+look(:down).kind_of?(Empty)
+```
+
+Ruby AI will flip/rotate the level randomly, so you can't just create a list of moves.
+
+Running the AI
+------------------
+
+Load a level and press enter to begin. Press up to increase speed or down to decrease speed. Press enter again to pause. Press escape to exit.
+
+Creating Levels
+-----------------------
+
+Each level is represented by a .png image. Each pixel represents one tile. I recommend the MacOS program Paintbrush, since Ruby AI will recognize the pre-made colors.
+
+The Player is orange, a.k.a. 'Tangerine' in Paintbrush.
+The Goal is green, a.k.a. 'Spring' in Paintbrush.
+Walls are brown, a.k.a. 'Mocha' in Paintbrush.
+Empty space is black, a.k.a. 'Licorice' in Paintbrush.
+
+Ruby AI _should_ support levels up to 64x64, but they will load slowly (if at all).

data/bin/ruby-ai

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+if ARGV[0] =='init'
+  bin_path = File.expand_path(File.dirname(__FILE__))
+  `cp #{bin_path}/../lib/ruby-ai/ai.rb .`
+  `cp -r #{bin_path}/../lib/ruby-ai/levels .`
+else
+  require "#{Dir.pwd}/ai"
+  require 'ruby-ai'
+  level = ARGV[0]
+  RubyAI.new(level).show
+end

data/lib/ruby-ai.rb

@@ -0,0 +1,194 @@
+#displays game, passes commands
+LIB = File.expand_path(File.dirname(__FILE__))
+
+require 'gosu'
+require 'texplay'
+require 'ruby-ai/goal'
+require 'ruby-ai/wall'
+require 'ruby-ai/empty'
+require 'ruby-ai/player'
+require 'ruby-ai/ui'
+
+class RubyAI < Gosu::Window
+  attr_reader :tiles
+
+  COLORS = {
+    :player => [1.0, 0.5764706134796143, 0.0, 1.0], #orange, paintbrush 'tangerine'
+    :goal => [0.0, 0.9764706492424011, 0.0, 1.0], #green, paintbrush 'spring'
+    :wall => [0.5803921818733215, 0.32156863808631897, 0.0, 1.0], #brown, paintbrush 'mocha'
+    :empty => [0.0, 0.0, 0.0, 1.0], #black, paintbrush 'licorice'
+  }
+
+  DIMS = {:x => 64, :y => 64}
+
+  def initialize(level)
+
+    super(DIMS[:x] * 10, DIMS[:y] * 10, false)
+
+    self.caption = 'Ruby AI'
+    @drawn = []
+    @ui = UI.new(self)
+    @drawn << @ui
+    @tiles = []
+    @level = level
+
+    load_level
+
+    @ai = AI.new(@player)
+    unless @ai.respond_to?('level', "#{@level}")
+      puts "Your AI class must define a method 'level(num)'"
+      @player.stop = true
+    end
+    @ai_tick = 0.5
+    @last_ai_update = Time.now
+  end
+
+  def load_level
+    level_image = Gosu::Image.new(self, "#{Dir.pwd}/levels/level#{@level}.png", false)
+    puts "Loading #{level_image.width * level_image.height} tiles."
+    image_dims = {:x => level_image.width, :y => level_image.height}
+
+    reverse = {:x => [true, false].sample, :y => [true, false].sample}
+    # reverse = {:x => false, :y => false}
+    rotate_by = [0, 90, 180, 270].sample
+    # rotate_by = 270
+
+    count = 0
+    coords = {}
+    mods = centering_modifiers(image_dims)
+
+    image_dims[:x].times do |x|
+      image_dims[:y].times do |y|
+        count += 1
+        if count > 99
+          print '.'
+          count = 0
+        end
+
+        coords[:x] = x
+        coords[:y] = y
+
+        [:x, :y].each do |dim|
+          coords[dim] = image_dims[dim] - 1 - coords[dim] if reverse[dim]
+        end
+
+        (rotate_by / 90).times do
+          rotate90!(image_dims, coords)
+        end
+
+        pixel = level_image.get_pixel(x, y)
+        add_tile(pixel, (coords[:x] + mods[:x]) * 10, (coords[:y] + mods[:y]) * 10)
+      end
+    end
+    puts 'Done.'
+  end
+
+  def centering_modifiers(image_dims)
+    mods = {:x => 0, :y => 0}
+    [:x, :y].each do |dim|
+      if image_dims[dim] < DIMS[dim]
+        diff = DIMS[dim]- image_dims[dim]
+        mods[dim] = diff / 2
+      end
+    end
+    mods
+  end
+
+  def rotate90!(dims, coords)
+    old = coords[:y]
+    coords[:y] = coords[:x]
+    coords[:x] = dims[:y] - 1 - old
+  end
+
+  def add_tile(pixel, x, y)
+    if pixel_equal?(pixel, COLORS[:wall])
+      wall = Wall.new(self, {:x => x, :y => y})
+      @tiles << wall
+      @drawn << wall
+    elsif pixel_equal?(pixel, COLORS[:player])
+      @player = Player.new(self, {:x => x, :y => y})
+      @drawn << @player
+
+      empty = Empty.new(self, {:x => x, :y => y})
+      @tiles << empty
+    elsif pixel_equal?(pixel, COLORS[:goal])
+      @goal = Goal.new(self, {:x => x, :y => y})
+      @tiles << @goal
+      @drawn << @goal
+    elsif pixel_equal?(pixel, COLORS[:empty])
+      empty = Empty.new(self, {:x => x, :y => y})
+      @tiles << empty
+    end
+  end
+
+  def pixel_equal?(pixel, values)
+    4.times do |i|
+      return false unless rough_equal?(pixel[i], values[i])
+    end
+    true
+  end
+
+  def rough_equal?(float1, float2)
+    one = (float1 * 100).to_i
+    two = (float2 * 100).to_i
+    one == two
+  end
+
+  def update
+    if won?
+      @ui.text = 'Success! Press <enter> to exit.'
+      return
+    end
+
+    if @player.stop
+      @ui.text = 'Game over. Press <enter> to exit.'
+      return
+    end
+
+    if @player.pause
+      @ui.text = 'Paused. Press <enter> to resume.'
+      return
+    end
+
+    @ui.text = ''
+
+    if Time.now - @last_ai_update > @ai_tick
+      @last_ai_update = Time.now
+      @player.send(:moved=, false)
+      @ai.level(@level.to_i)
+    end
+  end
+
+  def won?
+    return true if @won
+    if @player.x == @goal.x && @player.y == @goal.y
+      puts 'Success!'
+      @won = true
+    end
+  end
+
+  def draw
+    @drawn.each {|o| o.send(:draw)}
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    elsif id == Gosu::KbReturn
+      if @player.stop || @won
+        exit
+      end
+      if @player.pause
+        @player.pause = false
+      else
+        @player.pause = true
+      end
+    elsif id == Gosu::KbDown
+      @ai_tick = @ai_tick * 2 unless @ai_tick > 1
+    elsif id == Gosu::KbUp
+      @ai_tick = @ai_tick / 2 unless @ai_tick < 0.01
+    end
+  end
+
+
+end

data/lib/ruby-ai/ai.rb

@@ -0,0 +1,31 @@
+#Add your own AI code here.
+#You have two methods at your disposal:
+#  look(direction)
+#    use :up, :down, :left, :right, or nothing as your direction
+#    returns the tile in the specified direction, or the tile the player is currently standing on
+#
+#  move(direction)
+#    use :up, :down, :left, or :right as your direction
+#    moves the player in the specified direction
+#
+# You can cheat pretty easily if you like, but it's not as fun that way.
+
+class AI
+  attr_reader :player
+
+  def initialize(player)
+    @player = player
+  end
+
+  def level(num)
+    puts 'Add your own code to ai.rb'
+  end
+
+  private
+
+  #this method is required to allow method calls directly to player object
+  #exa. move(:up) vs player.move(:up)
+  def method_missing(m, *args)
+    player.send(m, *args)
+  end
+end

data/lib/ruby-ai/empty.rb

@@ -0,0 +1,11 @@
+#represents an empty space
+
+require 'ruby-ai/tile'
+class Empty < Tile
+  attr_reader :x, :y
+
+  def initialize(window, coords)
+    @x = coords[:x]
+    @y = coords[:y]
+  end
+end

data/lib/ruby-ai/goal.rb

@@ -0,0 +1,15 @@
+#represents the goal
+
+require 'ruby-ai/tile'
+class Goal < Tile
+  attr_reader :x, :y
+  def initialize(window, coords)
+    @image = Gosu::Image.new(window, "#{LIB}/ruby-ai/media/tiny-green.png", false)
+    @x = coords[:x]
+    @y = coords[:y]
+  end
+
+  def draw
+    @image.draw(@x, @y, 1)
+  end
+end

data/lib/ruby-ai/player.rb

@@ -0,0 +1,97 @@
+#holds player state, handles lose conditions
+
+require 'ruby-ai/tile'
+
+class Player < Tile
+  attr_accessor :pause, :stop
+  attr_reader :x, :y, :moved
+
+  def initialize(window, coords)
+    @image = Gosu::Image.new(window, "#{LIB}/ruby-ai/media/tiny-orange.png", false)
+    @tiles = window.tiles
+    @x = coords[:x]
+    @y = coords[:y]
+    @moved = false
+    @pause = true
+    @stop = false
+  end
+
+  def look(dir=nil, num=1)
+    return @tiles.find {|t| t.x == x && t.y == y} unless dir
+    at = send(dir, num)
+    tile = @tiles.find do |tile|
+      tile.x == at[:x] && tile.y == at[:y]
+    end
+    tile
+  end
+
+  def move(dir)
+    if moved? || hit_wall?(dir)
+      @stop = true
+      return
+    end
+
+    to = send(dir)
+    @x = to[:x]
+    @y = to[:y]
+    myputs "Moved #{dir}."
+  end
+
+  def stop=(val)
+    if val
+      puts 'Game Over.'
+      @stop = true
+    end
+  end
+
+  private
+
+  def up(num=1)
+    {:x => @x, :y => @y - num * 10}
+  end
+
+  def down(num=1)
+    {:x => @x, :y => @y + num * 10}
+  end
+
+  def left(num=1)
+    {:x => @x - num * 10, :y => @y}
+  end
+
+  def right(num=1)
+    {:x => @x + num * 10, :y => @y}
+  end
+
+  def moved?
+    if @moved
+      puts 'Already moved!'
+      true
+    else
+      @moved = true
+      false
+    end
+  end
+
+  def moved=(val)
+    @moved = val
+  end
+
+  def hit_wall?(dir)
+    if look(dir).kind_of?(Wall)
+      puts "You moved #{dir} and knocked yourself out against a wall."
+      true
+    else
+      false
+    end
+  end
+
+  def draw
+    @image.draw(@x, @y, 1)
+  end
+
+  def myputs(string)
+    @count ||= 0
+    @count += 1
+    puts "#{@count}. " + string
+  end
+end

data/lib/ruby-ai/tile.rb

@@ -0,0 +1,11 @@
+#access methods via brackets
+
+class Tile
+  def [](key)
+    send(key)
+  end
+
+  def inspect
+    "#{self.class}, @x=#{x}, @y=#{y}"
+  end
+end

data/lib/ruby-ai/ui.rb

@@ -0,0 +1,16 @@
+#prints text on screen
+
+class UI
+  attr_accessor :text
+
+  def initialize(window)
+    @font = Gosu::Font.new(window, Gosu::default_font_name, 15)
+    @text = 'Press <enter> to begin.'
+    @width = window.width
+    @height = window.height
+  end
+
+  def draw
+    @font.draw_rel(@text, @width / 2, @height - 20, 3, 0.5, 0.0, 1.0, 1.0, 0xffffff00)
+  end
+end

data/lib/ruby-ai/wall.rb

@@ -0,0 +1,16 @@
+#represents a wall
+
+require 'ruby-ai/tile'
+class Wall < Tile
+  attr_reader :x, :y
+
+  def initialize(window, coords)
+    @image = Gosu::Image.new(window, "#{LIB}/ruby-ai/media/tiny-brown.png", true)
+    @x = coords[:x]
+    @y = coords[:y]
+  end
+
+  def draw
+    @image.draw(@x, @y, 1)
+  end
+end

data/lib/ruby-ai/window.rb

@@ -0,0 +1,195 @@
+#displays game, passes commands
+
+require 'gosu'
+require 'texplay'
+require APP_DIR + 'ai'
+require APP_DIR + 'lib/goal'
+require APP_DIR + 'lib/wall'
+require APP_DIR + 'lib/empty'
+require APP_DIR + 'lib/player'
+require APP_DIR + 'lib/ui'
+require APP_DIR + 'lib/fake_window'
+
+class Window < Gosu::Window
+  attr_reader :tiles
+
+  COLORS = {
+    :player => [1.0, 0.5764706134796143, 0.0, 1.0], #orange, paintbrush 'tangerine'
+    :goal => [0.0, 0.9764706492424011, 0.0, 1.0], #green, paintbrush 'spring'
+    :wall => [0.5803921818733215, 0.32156863808631897, 0.0, 1.0], #brown, paintbrush 'mocha'
+    :empty => [0.0, 0.0, 0.0, 1.0], #black, paintbrush 'licorice'
+  }
+
+  DIMS = {:x => 64, :y => 64}
+
+  def initialize(level)
+
+    super(DIMS[:x] * 10, DIMS[:y] * 10, false)
+
+    self.caption = 'Ruby AI'
+    @drawn = []
+    @ui = UI.new(self)
+    @drawn << @ui
+    @tiles = []
+    @level = level
+
+    load_level
+
+    @ai = AI.new(@player)
+    unless @ai.respond_to?('level', "#{@level}")
+      puts "Your AI class must define a method 'level(num)'"
+      @player.stop = true
+    end
+    @ai_tick = 0.5
+    @last_ai_update = Time.now
+  end
+
+  def load_level
+    level_image = Gosu::Image.new(self, APP_DIR + "levels/level#{@level}.png", false)
+    puts "Loading #{level_image.width * level_image.height} tiles."
+    image_dims = {:x => level_image.width, :y => level_image.height}
+
+    reverse = {:x => [true, false].sample, :y => [true, false].sample}
+    # reverse = {:x => false, :y => false}
+    rotate_by = [0, 90, 180, 270].sample
+    # rotate_by = 270
+
+    count = 0
+    coords = {}
+    mods = centering_modifiers(image_dims)
+
+    image_dims[:x].times do |x|
+      image_dims[:y].times do |y|
+        count += 1
+        if count > 99
+          print '.'
+          count = 0
+        end
+
+        coords[:x] = x
+        coords[:y] = y
+
+        [:x, :y].each do |dim|
+          coords[dim] = image_dims[dim] - 1 - coords[dim] if reverse[dim]
+        end
+
+        (rotate_by / 90).times do
+          rotate90!(image_dims, coords)
+        end
+
+        pixel = level_image.get_pixel(x, y)
+        add_tile(pixel, (coords[:x] + mods[:x]) * 10, (coords[:y] + mods[:y]) * 10)
+      end
+    end
+    puts 'Done.'
+  end
+
+  def centering_modifiers(image_dims)
+    mods = {:x => 0, :y => 0}
+    [:x, :y].each do |dim|
+      if image_dims[dim] < DIMS[dim]
+        diff = DIMS[dim]- image_dims[dim]
+        mods[dim] = diff / 2
+      end
+    end
+    mods
+  end
+
+  def rotate90!(dims, coords)
+    old = coords[:y]
+    coords[:y] = coords[:x]
+    coords[:x] = dims[:y] - 1 - old
+  end
+
+  def add_tile(pixel, x, y)
+    if pixel_equal?(pixel, COLORS[:wall])
+      wall = Wall.new(self, {:x => x, :y => y})
+      @tiles << wall
+      @drawn << wall
+    elsif pixel_equal?(pixel, COLORS[:player])
+      @player = Player.new(self, {:x => x, :y => y})
+      @drawn << @player
+
+      empty = Empty.new(self, {:x => x, :y => y})
+      @tiles << empty
+    elsif pixel_equal?(pixel, COLORS[:goal])
+      @goal = Goal.new(self, {:x => x, :y => y})
+      @tiles << @goal
+      @drawn << @goal
+    elsif pixel_equal?(pixel, COLORS[:empty])
+      empty = Empty.new(self, {:x => x, :y => y})
+      @tiles << empty
+    end
+  end
+
+  def pixel_equal?(pixel, values)
+    4.times do |i|
+      return false unless rough_equal?(pixel[i], values[i])
+    end
+    true
+  end
+
+  def rough_equal?(float1, float2)
+    one = (float1 * 100).to_i
+    two = (float2 * 100).to_i
+    one == two
+  end
+
+  def update
+    if won?
+      @ui.text = 'Success! Press <enter> to exit.'
+      return
+    end
+
+    if @player.stop
+      @ui.text = 'Game over. Press <enter> to exit.'
+      return
+    end
+
+    if @player.pause
+      @ui.text = 'Paused. Press <enter> to resume.'
+      return
+    end
+
+    @ui.text = ''
+
+    if Time.now - @last_ai_update > @ai_tick
+      @last_ai_update = Time.now
+      @player.send(:moved=, false)
+      @ai.level(@level.to_i)
+    end
+  end
+
+  def won?
+    return true if @won
+    if @player.x == @goal.x && @player.y == @goal.y
+      puts 'Success!'
+      @won = true
+    end
+  end
+
+  def draw
+    @drawn.each {|o| o.send(:draw)}
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    elsif id == Gosu::KbReturn
+      if @player.stop || @won
+        exit
+      end
+      if @player.pause
+        @player.pause = false
+      else
+        @player.pause = true
+      end
+    elsif id == Gosu::KbDown
+      @ai_tick = @ai_tick * 2 unless @ai_tick > 1
+    elsif id == Gosu::KbUp
+      @ai_tick = @ai_tick / 2 unless @ai_tick < 0.01
+    end
+  end
+
+
+end

data/ruby-ai.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name = 'ruby-ai'
+  s.version = '0.0.2'
+  s.executables << 'ruby-ai'
+  s.date = '2013-09-24'
+  s.summary = 'ruby-ai'
+  s.description = 'Write AI code for this simple game.'
+  s.authors = ['Tyler Hartland']
+  s.email = 'tylerhartland7@gmail.com'
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'http://rubygems.org/gems/ruby-ai'
+  s.license = 'MIT'
+  s.add_runtime_dependency 'gosu', ['~> 0.7']
+  s.add_runtime_dependency 'texplay', ['~> 0.4']
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: ruby-ai
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Tyler Hartland
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: texplay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Write AI code for this simple game.
+email: tylerhartland7@gmail.com
+executables:
+- ruby-ai
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/ruby-ai
+- lib/ruby-ai.rb
+- lib/ruby-ai/ai.rb
+- lib/ruby-ai/empty.rb
+- lib/ruby-ai/goal.rb
+- lib/ruby-ai/levels/level1.png
+- lib/ruby-ai/levels/level2.png
+- lib/ruby-ai/levels/level3.png
+- lib/ruby-ai/levels/level4.png
+- lib/ruby-ai/levels/level5.png
+- lib/ruby-ai/levels/level6.png
+- lib/ruby-ai/levels/level7.png
+- lib/ruby-ai/media/tiny-black.png
+- lib/ruby-ai/media/tiny-blue.png
+- lib/ruby-ai/media/tiny-brown.png
+- lib/ruby-ai/media/tiny-green.png
+- lib/ruby-ai/media/tiny-orange.png
+- lib/ruby-ai/media/tiny-purple.png
+- lib/ruby-ai/media/tiny-red.png
+- lib/ruby-ai/media/tiny-yellow.png
+- lib/ruby-ai/player.rb
+- lib/ruby-ai/tile.rb
+- lib/ruby-ai/ui.rb
+- lib/ruby-ai/wall.rb
+- lib/ruby-ai/window.rb
+- ruby-ai-0.0.1.gem
+- ruby-ai.gemspec
+homepage: http://rubygems.org/gems/ruby-ai
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: ruby-ai
+test_files: []