brawl 0.0.0.alpha → 0.0.3

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+.DS_Store

data/README.md

@@ -0,0 +1,43 @@
+# Brawl
+
+A dangerous robotic programming game that will kill you in your sleep.
+
+Write robotic assassins using Ruby and watch them as they do your evil bidding.
+
+## Status
+**Alpha Development**
+
+Brawl is a work in progress but currently supports running bots on your local machine with limited security.
+
+## Features
+The framework is designed from the ground up to be extendable. Want to add some new functionality to robots like dropping land mines, semi-intelligent turrets, or heat seeking missiles? Just write a new part and load it into your bot.
+
+## Security
+Brawl was also designed to be secure (when the DRb methodology is implemented). In the secure version (in prototype stage now) bot code runs in a $SAFE = 3 process fork and communicates via a wrapper that uses DRb to talk to a proxy object. 
+
+Whew, that was a mouth full but what it basically means is you can feel reasonably safe running other people's code on your machine. They won't be able to erase your hard drive, probably, much less hack your bots or the game engine to cheat.
+
+Legal Notice: This is not a guarantee of fitness or anything else. If you use other people's code without understanding what it does expect your entire system to melt.
+
+## Example bot programs
+
+This is a really dumb robot that just scans for enemies and shoots at them. If it can't find an enemy it will move around till it does. How would you improve it?  
+
+    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
+  

data/_design/ClassDescriptions.txt

@@ -0,0 +1,98 @@
+Brainstorming how it's all going to fit together. 
+I'll probably toss a lot of this as I get into coding but this helps me think about the problem.
+
+
+Code loader
+Encapsulates code input.
+
+This could be from a file, a webpage, a database, etc.
+
+
+BasicRobot
+Defines the minimum objects a robot should have.
+
+For instance it should have a motor, a scanner, a weapon, and a shield
+
+
+BasicObject?
+Should I define a basic object or objects like weapons, motors, scanners, or just a basic object that can interact with the world.
+
+It could have properties like x,y... that couples it to the Area though doesn't it?
+
+
+RobotSpecs
+A model that describes how many points are assigned to each component of a robot.
+
+Does this even need to be a class? It's basically just an array. Maybe this can encapsulate how to read that using given Data API.
+
+
+RobotRules
+This model defines how many points mean what in a RobotSpec.
+
+For instance how much damage a Laser set to 8 does or how much damage a shield set to 4 mitigates. This is how the game will be balanced.
+
+
+Code parser/DSL
+Handles converting raw bot code into runnable code.
+
+
+Code runner
+Runs the code in a safe manner.
+
+This will most likely be by containing it in a tread with $SAFE = 4.
+
+
+Communication Layer
+Sends messages back and forth between the arena and the code runner.
+
+This could be as simply as wiring up the receive to the transmit and vice versa for local running to a web based interface using Sinatra.
+It should handle communication from multiple clients securely (a bot shouldn't be able to lie about who it is)
+
+
+BotController
+This controller is the glue that pushes all the buttons of the classes needed to make a bot run like: Code loader, Code parser, a communication layer, and the code runner.
+
+
+ArenaController
+Orchestrates all the classes needed to make combat work like Layouts, Arena and Bot Rules, and ScoreKeeping.
+
+
+ArenaLayout
+The model that describes what an arena looks like.
+
+How long and wide it is and where obstacles are.
+
+
+ArenaRules
+A model that contains rules for battles.
+
+This could be things like how many battles to fight, the maximum number of points allowed for a bot, time limits, etc.
+
+
+ScoreKeeping
+Stores the results of battles.
+
+
+Data API
+Basic interface to datastores.
+
+This could be a JSON or YAML file or a database. This should be injected into a model so the model knows how to read data.
+
+
+Config
+Bootstraps the basic configuration for the ApplicationController.
+
+This might contain server locations, DataAPI types, and communication layer types. 
+
+
+Application Controller
+This is what orchestrates all the other classes into a usable application.
+
+This could be a CLI 'bot developer client or server or it could decide what it is by the way you run it. It could run a GUI.
+
+
+BattleView
+Displays information about a running battle and its results.
+
+
+

data/_design/Psudo_Program.rb

@@ -0,0 +1,113 @@
+# Brainstorming what a bot program might look like so I can figure out how to deal with it
+
+# I've removed the idea of throttling. Throttling changes the model from event based
+# to event/queue based so then there's no point in multi-threading in the first place.
+
+# Bots are divided into classes by points and attachments (mixin modules that add more functionality)
+# A basic bot might be allowed 10 points to allocate. The more points the better the system of course.
+# 
+
+# This defines your robot's characteristics
+Bot.build
+  {
+    # required
+    scanner:      2,
+    motor:        2,
+    laser:        2,
+    shield:       4,
+    # optional
+    name:         "Full function bot",
+    author:       "Mike Bethany",
+    description:  "A simple but full featured robot to show all the capabilities",
+    revision:     '0.0.1',
+  }
+# Should there be some kind of GUID handed out by a central command to identify bots?
+
+# These are things that can happen and should be responded to
+event :enemy_found
+event :enemy_lost
+
+# This loop looks for an enemy and tries to track it
+# (loop creates a thread)
+@contact = nil
+BasicScanner.loop do
+  # try to keep the scanner locked on the enemy
+  if @contact and @contact.is_enemy?
+    direction, sweep, range = contact.direction - 5, 10, @contact.range + 2
+  else
+    # lazy scanning 
+    # It's very slow since it's scanning the maximum range in a full circle
+    direction, sweep, range = 0, 360, :max
+  end
+  @contact = scan direction: direction, sweep: sweep, range: range
+end
+
+# Another scanner thread that is a lot faster and just looks for walls
+BasicScanner.loop do
+  if check_for_walls(:front)
+    [:left, :right].each do |direction|
+      @walls[direction] = check_for_walls(direction)
+    end
+  end 
+  fire_event(:wall)
+end
+
+def check_for_walls(direction)
+  # This is a really fast scan because it's scanning the minimum distance at only 1 degree
+  !BasicScanner.scan direction: direction, sweep: 1, range: Motor.speed
+end
+
+BasicScanner.loop do
+
+end
+
+# Another low priority thread that moves the bot around randomly
+Motor.loop do
+
+  if Motor.dead_end
+    reverse
+    Motor.dead_end = false
+  else
+    # mostly go straight but turn randomly sometimes
+    unless rand(100) > 70 and check_for_wall(:front)
+      forward unless Motor.direction == :forward
+    else
+      # turning takes time and is blocking
+      Motor.dead_end = random_turn
+    end
+  end
+
+end
+
+def random_turn
+  directions = [:left,:right]
+  while pick = directions.delete(rand(directions.length)) 
+    unless check_for_wall(pick)
+      turn pick
+      break
+    end
+  end
+  !directions.is_empty?
+end
+
+# This does not create a thread/loop but instead dynamcially creates a method using the given block
+# You can call it whatever you want as long as you don't pick something that's already taken.
+# If you try to overwrite methods that are important to the bot like forward or reverse they 
+# won't be used since this would break the system's ability to interact with your bot.
+Laser.engage do |contact|
+  # lazy aiming (a better approach might be to remember the last few contacts and try to extrapolate location)
+
+  # Aim sends the command to move the turrent but it's a non-blocking call
+  aim contact.direction
+
+  # Since aim is a non-blocking call you might not actually be pointed at the enemy yet
+  fire if contact.distance <= Laser.range and BasicScanner.scan direction: contact.direction, sweep: 3, range: contact.distance, priority: 5
+end
+
+# Again this method is created dynamically using the given block
+Motor.pursue do |contact|
+
+end
+
+
+

data/_design/array.rb

@@ -0,0 +1,4 @@
+puts Array.public_methods(false)
+puts
+puts
+puts Array.new.public_methods(false).sort.inspect

data/_design/threads.rb

@@ -0,0 +1,71 @@
+Thread.abort_on_exception = true
+
+class Time
+  def self.time
+    Time.now.strftime("%H:%M:%S.%L")
+  end
+end
+
+module Kernel
+  def tputs(message)
+    puts "#{Time.time}   #{message}"
+  end
+end
+
+class Resource
+  @mutex = Mutex.new
+
+  def self.do(count, time)
+    tputs "do: #{count}"
+    count.times do |index|
+      self.use(count, time, index)
+    end
+  end
+
+  def self.use(count, time, index)
+    @mutex.synchronize do
+      timeout = Time.now + time
+      sleep(0.01) while Time.now < timeout
+      tputs "#{index} for count: #{count}"
+    end
+    # This sleep seems to be crucial. The mutex is released but if I
+    # don't have a sleep here the next thing waiting for the mutex 
+    # doesn't seem to get the resource.
+    sleep(0.001)
+  end
+
+end
+
+class Worker
+
+  def initialize(&block)
+    @block = block
+  end
+
+  def start
+    @stop_working = nil
+    tputs "Starting: #{@block}"
+    Thread.new do
+      until @stop_working
+        @block.call
+      end
+    end
+  end
+
+  def stop
+    @stop_working = false
+  end
+end
+
+#slow = Worker.new {Resource.do_something(5,0.2)}
+#fast = Worker.new {sleep(0.5);Resource.do_something(1,0.1)}
+slow = Worker.new {Resource.do(3,0.25)}
+fast = Worker.new {sleep(1.5); Resource.do(1,0.1)}
+slow.start
+fast.start
+stop = Time.now + 5
+sleep(0.01) while stop > Time.now
+
+slow.stop
+fast.stop
+

data/_spike/Communications/communications.rb

@@ -0,0 +1,2 @@
+require_relative "communications/null_modem"
+require_relative "communications/com_linker"

data/_spike/Communications/lib/communications/com_linker.rb

@@ -0,0 +1,11 @@
+module Brawl
+  module Communications
+    class ProxyGenerator
+      def self.link(com_layer, server)
+        client.public_methods(false).each do |method|
+          com_layer.link_method(client, server, method)
+        end
+      end
+    end
+  end
+end

data/_spike/Communications/lib/communications/null_modem.rb

@@ -0,0 +1,11 @@
+module Brawl
+  module Communications
+    class NullModem
+      def link_method(client, server, method)
+        client.class.send :define_method, method do |*params, &block|
+          server.send method, *params, &bloc
+        end
+      end
+    end
+  end
+end

data/_spike/Communications/spec/communications/com_linker_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Brawl::Communications::Linker do
+
+  it "should link two classes using a communication class"
+
+end
+
+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

data/_spike/DRb/arena.rb

@@ -0,0 +1,32 @@
+class Arena
+  attr_accessor :counter
+  def initialize
+    @counter = ""
+    @bots = {}
+  end
+  
+  def add_bot(client_id)
+    @bots[client_id] = {location: 0}
+  end
+  
+  def move(value, client_id)
+    puts "move called: #{value.inspect}; #{client_id}"
+    @bots[client_id][:location] += value.first
+  end
+  
+end
+
+class ArenaProxy
+  
+  attr_accessor :client_id
+  
+  def initialize(arena, client_id=nil)
+    @arena      = arena
+    @client_id  = client_id
+  end
+  
+  def move(amount)
+    @arena.move(amount, client_id)
+  end
+  
+end