brawl 0.0.0.alpha → 0.0.3

data/_spike/break.rb

@@ -0,0 +1,10 @@
+
+def foo(stop_at)
+  (0...100).each do |index|
+    break index if index == stop_at
+  end
+  
+end
+
+
+puts foo(20)

data/_spike/circles.rb

@@ -0,0 +1,29 @@
+require "bigdecimal"
+require "bigdecimal/math"
+
+include BigMath
+
+def to_radians(angle)
+  big_angle = BigDecimal(angle.to_s)
+  big_angle * (PI(100) / 180.0)
+end
+
+def to_degree(angle)
+  big_angle = BigDecimal(angle.to_s)
+  big_angle * (180.0 / PI(100))
+end
+
+
+angle = -320
+puts "angle: #{angle}"
+radians = to_radians angle
+sin = Math.sin(radians).abs
+puts "rad:   #{radians}"
+puts "sin:   #{sin}"
+asin = Math.asin(sin)
+puts "asin:  #{asin}"
+wrap_angle =  to_degree asin
+puts "wrap:  #{wrap_angle.round}"
+# radian90 = to radian: 90
+# puts "90 degrees to radian:  #{radian90}"
+# puts "90 radians to degrees: #{to degree: radian90}"

data/_spike/cleaner_attribs.rb

@@ -0,0 +1,13 @@
+class Foo
+  attr_accessor :bar
+  def initialize(args={})
+    args.each do |key, value|
+      instance_variable_set("@#{key}", value) if public_methods(false).include? key
+    end
+  end
+end
+
+puts Foo.instance_methods(false)
+
+f = Foo.new(bar: "foo!")
+puts f.bar

data/_spike/comlink.rb

@@ -0,0 +1,61 @@
+class Foo
+  def bar(value)
+    "doh!"
+  end
+  def baz(value1, value2)
+    "Oh, noos!"
+  end
+  def qux
+    "Fudge!"
+  end
+  def quux(value1, value2, &block)
+    "Nope, nope, nope"
+  end
+end
+
+class FooProxy
+  def bar(value)
+    "#{value}"
+  end
+  def baz(value1, value2)
+    "#{value1}, #{value2}"
+  end
+  def qux
+    yield "FooProxy"
+  end
+  def quux(value1, value2, &block)
+    yield ["FooProxy", "#{value1}, #{value2}"]
+  end
+end
+
+class NullModem
+  def link_method(client, server, method)
+    client.class.send :define_method, method do |*params, &block|
+      server.send method, *params, &block
+    end
+  end
+end
+
+class ComLinker
+  def self.link(comlayer, client, server)
+    client.public_methods(false).each do |method|
+      comlayer.link_method(client, server, method)
+    end
+  end
+end
+
+
+foo = Foo.new
+proxy = FooProxy.new
+comlayer = NullModem.new
+
+ComLinker.link(comlayer, foo, proxy)
+
+puts foo.bar("hello!")
+puts foo.baz("howdy", "ho")
+puts foo.qux {|value| value}
+puts (foo.quux("look", "at this") {|value| value}).inspect
+
+
+
+

data/_spike/concat.rb

@@ -0,0 +1,27 @@
+require 'benchmark'
+
+x = [1,2,3]
+puts x.object_id
+
+x.concat [4,5] # same object
+puts x.object_id
+
+x += [6,7] # different object
+puts x.object_id
+
+
+Benchmark.bmbm do |bm|
+  x = ("X"*100).split("")
+  y = ("Y"*100).split("")
+  times = 1000
+
+  bm.report{times.times {x.concat y}}
+  bm.report{times.times {x += y}} # substantially slower
+  
+end
+
+=begin
+  user     system      total        real
+0.000000   0.000000   0.000000 (  0.001476)
+2.950000   2.140000   5.090000 (  6.061063)
+=end

data/_spike/example_bot.rb

@@ -0,0 +1,42 @@
+class BasicBot
+  
+end
+
+# this isn't meant to be a good bot, just to show the features of bots
+code.loop do |bot|
+
+  scan_results = bot.scan direction: 0, angle: 45
+  
+  unless (enemies = scan_results.contacts.select 
+    {|contact| contact.type == :enemy}).empty?
+
+    # you should get the closest probably, not just the first in the array
+    enemy = enemies.first
+    
+    if enemy.distance <= bot.weapon.range do
+      bot.fire direction: enemy.direction
+    else
+      bot.turn direction: enemy.direction
+      bot.move
+    end
+    
+  else
+    
+    # No enemy spotted so move around randomly
+    # mostly go straight but turn randomly sometimes
+    unless rand(100) > 70 and scan_result.any? 
+      {|contact| contact.direction == :front && contact.distance == 1}
+      bot.move direction: :forward
+    else
+      [:right, :left].sample do |direction|
+        # if the enemy gets right behind you, you could go into an endless loop
+        bot.turn direction until 
+          (bot.scan direction: 0, angle: 0).contacts.empty
+        
+        bot.move
+      end
+    end
+    
+  end
+
+end

data/_spike/forwarding_instance.rb

@@ -0,0 +1,32 @@
+require 'forwardable'
+
+class Bar
+  def baz
+    puts "baz!"
+  end
+end
+
+class Foo
+  extend Forwardable
+  
+  attr_accessor :parts
+  
+  def initialize(args)
+    
+    @parts = args[:parts]
+
+    @parts.each do |part, instance|
+      instance_variable_set("@#{part}", instance)
+      self.class.def_delegators "@#{part}", *(instance.public_methods(false))
+    end
+    
+  end
+  
+end
+
+
+f = Foo.new(parts: {bar: Bar.new})
+puts f.public_methods(false)
+puts
+puts f.instance_variables
+f.baz

data/_spike/hash_loop.rb

@@ -0,0 +1,17 @@
+x = [{a: "a"}, {b: "b"}, {c: "c"}]
+
+class Hash
+  def each_hash
+    self.each_pair do |key, value|
+      yield key => value
+    end
+  end
+end
+
+def foo(hashes)
+  hashes.each_hash do |hash|
+    puts hash.inspect
+  end
+end
+
+foo(a: "a", b: "b", c: "c")

data/_spike/hashing.rb

@@ -0,0 +1,7 @@
+x = [:a, :b, :c, :d, :e]
+
+y = x.each_with_object({}) do |key, hash|
+  hash[key] = key.to_s.ord
+end
+
+puts y

data/_spike/hook.rb

@@ -0,0 +1,19 @@
+class Foo
+  
+  def initialize
+    singleton_class.send :alias_method, :__hook__, :bar
+    singleton_class.send :define_method, :bar do |*params|
+      puts "no mo ba"
+      send :__hook__
+    end
+  end
+  
+  def bar
+    puts "bar"
+  end
+  
+end
+
+f = Foo.new
+
+f.bar

data/_spike/mod.rb

@@ -0,0 +1,10 @@
+def foo
+  
+  class Doo
+    def something
+      puts "somthing"
+    end
+  end
+  
+end
+

data/_spike/point_in_cone.rb

@@ -0,0 +1,20 @@
+
+def point_in_cone(args)
+  radius, angle, direction, bot, target = args[:radius], args[:angle], args[:direction], args[:bot], args[:target]
+  x1, y1, x2, y2 = bot[:x], bot[:y], target[:x], target[:y]
+  distance = Math.sqrt((x1 - target[:x])**2 + (y1 - y2)**2)
+  return false if distance > radius
+  
+  azimuth = Math.atan2(x2 - x1, y2 - y1)
+  
+  min = (Math::PI / 180) * ((direction - (angle / 2)) % 360)
+  max = (Math::PI / 180) * ((direction + (angle / 2)) % 360)
+
+  if min > max
+    azimuth >= min || azimuth <= max
+  else
+    azimuth >= min && azimuth <= max
+  end
+end
+
+puts point_in_cone radius: 10, angle: 90, direction: 0, bot: {x: 0, y: 0}, target: {x: 10, y: 0}

data/_spike/runner.rb

@@ -0,0 +1,44 @@
+class Arena
+  def initialize
+    @secret = "super secret"
+  end
+  
+  def protected
+    puts "protected called"
+  end
+  
+end
+
+class ArenaProxy
+  def initialize(arena)
+    @arena = arena
+  end
+end
+
+class BasicBot
+  def initialize(arena_proxy)
+    @arena_proxy = arena_proxy
+  end
+end
+
+class Code
+  def self.loop
+    arena = Arena.new
+    ap    = ArenaProxy.new(arena)
+    bot   = BasicBot.new(ap)
+    yield bot
+  end
+end
+
+module Runner
+  secret = ""
+  Thread.start {
+    $SAFE = 4
+      Code.loop do |bot|
+        ap = bot.instance_variable_get(:@arena_proxy)
+        a  = ap.instance_variable_get(:@arena)
+        secret = a.instance_variable_get(:@secret)
+      end
+  }.join
+  puts secret
+end

data/_spike/safe.rb

@@ -0,0 +1,28 @@
+class Bar
+  def private_parts
+    "huge"
+  end
+end
+
+class Foo
+  def initialize
+    @bar = Bar.new
+    @secret = ["secret"]
+  end
+  
+end
+
+f = Foo.new
+vars = []
+vars.taint
+Thread.start {
+  $SAFE = 3
+  bar = Bar.new
+  f.instance_variable_set :@secret, "hahahaha"
+  vars  = f.instance_variable_get(:@secret)
+  bar   = f.instance_variable_get(:@bar)
+  vars  << "#{vars}, #{bar.private_parts}"
+}.join
+
+puts "vars: #{vars}"
+puts "Done"

data/brawl.gemspec

@@ -8,10 +8,11 @@ Gem::Specification.new do |s|
   s.authors     = ["Mike Bethany"]
   s.email       = ["mikbe.tk@gmail.com"]
   s.homepage    = "http://mikbe.tk"
-  s.summary     = %q{A work in progress}
-  s.description = %q{nothing to see here, move along}
+  s.summary     = %q{A robot combat game where you write Ruby programs to control your robots.}
+  s.description = %q{Write robotic assassins using Ruby and watch them as they do your evil bidding.}
 
-  s.rubyforge_project = "brawl"
+  s.add_dependency "uuidtools"
+  s.add_dependency "eventable"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/example/example_battle.rb

@@ -0,0 +1,173 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+$: << '.'
+
+require 'brawl'
+
+battle_bot_code = <<CODE
+code do |bot|
+  @dir ||= 0
+  targets = bot.scan direction: @dir, angle: 90
+  @dir += 45
+  @dir %= 360
+  unless targets.each do |target|
+      unless target[:class] == Brawl::Wall
+        results = shoot(target[:bearing])
+      end
+    end.empty?
+  else
+    if rand(0) > 0.5
+      bot.turn [:left,:right,:around].sample
+    end
+    bot.move rand(3) + 1
+  end
+end
+CODE
+
+arena_data = {size: {width: 10, length: 10}}
+clock_data = {tick_rate: 0.01}
+
+motor   = {Brawl::BasicMotor=>{move_max: 3, turn_max: 360}}
+scanner = {Brawl::BasicScanner=>{scan_max: 10, angle_max: 180}}
+weapon  = {Brawl::BasicWeapon=>{range: 11, power: 1}}
+parts   =  motor.merge(scanner).merge(weapon)
+
+battle_bot1 =
+{
+  name: "Battle Bot 1",
+  class: Brawl::BasicBot,
+  params: {parts: parts},
+  code: battle_bot_code
+}
+
+battle_bot2 =
+{
+  name: "Battle Bot 2",
+  class: Brawl::BasicBot,
+  params: {parts: parts},
+  code: battle_bot_code
+}
+
+battle_bot3 =
+{
+  name: "Battle Bot 3",
+  class: Brawl::BasicBot,
+  params: {parts: parts},
+  code: battle_bot_code
+}
+
+battle_bot4 =
+{
+  name: "Battle Bot 4",
+  class: Brawl::BasicBot,
+  params: {parts: parts},
+  code: battle_bot_code
+}
+
+class LogView
+
+  def initialize(logfile)
+    @logfile = logfile
+    @file = nil
+    @verbosity_throttle = 0
+    @verbosity_level = 25
+  end
+
+  def open
+    @file = File.open(@logfile, "w")
+  end
+
+  def close
+    @file.flush
+    @file.close
+  end
+
+  def write(msg="")
+    @file.puts msg
+  end
+
+  def bot_msg_callback(*params)
+
+    bot_info      = params[0]
+    method        = params[1]
+    method_params = params[2]
+    @verbosity_throttle += 1
+    
+    case method
+      when :damage
+        text = "#{bot_info[:name]}" +
+        " at #{bot_info[:location]}" +
+        " was hit for #{method_params} damage" +
+        " and now has #{bot_info[:health]} health."
+        text += " #{bot_info[:name]} is dead!" if bot_info[:health] == 0
+        @file.puts
+        @file.puts text
+        puts 
+        puts text
+      when :scan
+        text = "#{bot_info[:name]}" +
+        " at #{bot_info[:location]}" +
+        " scans #{method_params}"
+        @file.puts
+        @file.puts text
+        if speak?
+          puts 
+          puts text
+        end
+       when :move
+        text = "#{bot_info[:name]}" +
+        " at #{bot_info[:location]}" +
+        " moves #{method_params}"
+        @file.puts
+        @file.puts text
+        if speak?
+          puts 
+          puts text
+        end
+      when :shoot
+        text = "#{bot_info[:name]}" +
+        " at #{bot_info[:location]}" +
+        " shoots at bearing #{method_params.round(1)}."
+        @file.puts
+        @file.puts text
+        puts 
+        puts text
+    end
+  end
+  
+  def speak?
+    @verbosity_throttle % @verbosity_level == 0
+  end
+
+end
+
+battle = Brawl::BattleController.new
+battle.make_arena(arena_data)
+battle.make_clock(clock_data)
+
+bot_data = [battle_bot1, battle_bot2, battle_bot3, battle_bot4]
+battle.make_bots(bot_data)
+log = LogView.new("logview.txt")
+log.open
+battle.register_for_event(
+  event:    :bot_msg,
+  listener: log,
+  callback: :bot_msg_callback
+)
+
+battle.start
+until battle.victory?
+  sleep(0.5)
+end
+
+winner = battle.arena.get_object(class: Brawl::BasicBot)
+if winner
+  done_text = "Battle won!\n#{winner[:name]} is the champion!"
+else
+  done_text = "Battle draw! The last two bots killed other simultaniously! Doh!"
+end 
+
+puts
+puts done_text
+log.write
+log.write done_text
+log.close