ruby_arena 0.0.2

data/lib/ruby_arena/level0.rb

@@ -0,0 +1,6 @@
+module RubyArena
+  class Level0 < Ai
+    def tick(events)
+    end
+  end
+end

data/lib/ruby_arena/level1.rb

@@ -0,0 +1,9 @@
+module RubyArena
+  class Level1 < Ai
+    def tick(events)
+      set_radar_view_angle(5)
+      turn_gun(4)
+      fire if events[:scanned_robots].any?
+    end
+  end
+end

data/lib/ruby_arena/movable.rb

@@ -0,0 +1,18 @@
+module RubyArena
+  module Movable
+    def move
+      @x += offset_x(heading, speed)
+      @y += offset_y(heading, speed)
+    end
+
+    private
+
+    def offset_x(heading, speed)
+      Gosu.offset_x(heading, speed)
+    end
+
+    def offset_y(heading, speed)
+      Gosu.offset_y(heading, speed)
+    end
+  end
+end

data/lib/ruby_arena/option_parser.rb

@@ -0,0 +1,29 @@
+class OptionParser
+  def self.parse(args)
+    options = {}
+
+    opt_parser = OptionParser.new do |opts|
+      opts.banner = %{Usage: ruby_arena -l <level> [ai_file]
+Usage: ruby_arena <ai_file1> [ai_file2] ... [ai_fileN]
+      }
+
+      opts.on("-l", "--level level_number", Integer, "Specify level") do |l|
+        options[:level] = l
+      end
+
+      if args.empty?
+        puts opts
+        exit
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end
+
+    opt_parser.parse!(args)
+
+    options
+  end
+end

data/lib/ruby_arena/robot.rb

@@ -0,0 +1,196 @@
+module RubyArena
+  class Robot
+    include Movable
+
+    SIZE = 40
+    MAX_SPEED = 8
+    MAX_TURN_ANGLE = 10
+    MAX_TURN_GUN_ANGLE = 30
+    MAX_TURN_RADAR_ANGLE = 60
+    RADAR_RANGE = 1000
+    DEFAULT_RADAR_VIEW_ANGLE = 10
+
+    attr_reader :ai, :tank, :command_parser, :arena
+    attr_reader :x, :y, :speed, :heading, :gun_heading, :radar_heading, :robot
+    attr_reader :energy, :gun_heat
+    attr_accessor :radar_view_angle
+
+    def initialize(args)
+      @command_parser = CommandParser.new
+      @ai = args.fetch(:ai).new(robot: self, command_parser: command_parser)
+      @arena = args.fetch(:arena)
+      @x = args[:x] || rand(arena.width - 2*size)
+      @y = args[:y] || rand(arena.height - 2*size)
+      @speed = args[:speed] || 0
+      @heading = args[:heading] || 0
+      @gun_heading = args[:gun_heading] || heading
+      @radar_heading = args[:radar_heading] || gun_heading
+      @energy = args[:energy] || 100
+      @scanned_robots = []
+      @gun_heat = args[:gun_heat] || 0
+      @radar_view_angle = args[:radar_view_angle] || DEFAULT_RADAR_VIEW_ANGLE
+    end
+
+    def tick
+      ai.tick(tick_events)
+      @gun_heat -= 0.1 if @gun_heat > 0
+    end
+
+    def update
+      execute_actions(actions)
+      reset_actions
+      move
+      fix_position
+    end
+
+    def execute_actions(actions)
+      fire if actions[:fire]
+      turn(actions[:turn]) if actions[:turn]
+      turn_gun(actions[:turn_gun]) if actions[:turn_gun]
+      turn_radar(actions[:turn_radar]) if actions[:turn_radar]
+      accelerate if actions[:accelerate]
+      decelerate if actions[:decelerate]
+      self.radar_view_angle = actions[:radar_view_angle] if actions[:radar_view_angle]
+    end
+
+    def actions
+      command_parser.actions
+    end
+
+    def reset_actions
+      command_parser.reset_actions
+    end
+
+    def accelerate
+      @speed += 1 if speed < MAX_SPEED
+    end
+
+    def decelerate
+      @speed -= 1 if speed > -MAX_SPEED
+    end
+
+    def turn(angle)
+      angle = sanitize_maximum_value(angle, MAX_TURN_ANGLE)
+      self.heading = heading + angle
+      self.gun_heading = gun_heading + angle
+      self.radar_heading = radar_heading + angle
+    end
+
+    def turn_gun(angle)
+      angle = sanitize_maximum_value(angle, MAX_TURN_GUN_ANGLE)
+      self.gun_heading = gun_heading + angle
+      self.radar_heading = radar_heading + angle
+    end
+
+    def turn_radar(angle)
+      angle = sanitize_maximum_value(angle, MAX_TURN_RADAR_ANGLE)
+      self.radar_heading = radar_heading + angle
+    end
+
+    def fire
+      unless gun_heat > 0
+        bullet = new_bullet
+        arena.add_bullet(bullet)
+        3.times { bullet.update }
+        @gun_heat += 3
+      end
+    end
+
+    def hit(bullet)
+      @energy -= bullet.energy
+    end
+
+    def dead?
+      energy < 0
+    end
+
+    def scan
+      other_robots.map do |robot|
+        if robot_in_radar_view?(robot)
+          Gosu.distance(x, y, robot.x, robot.y)
+        end
+      end.compact
+    end
+
+    def size
+      SIZE
+    end
+
+    def radar_range
+      RADAR_RANGE
+    end
+
+    def time
+      arena.time
+    end
+
+    private
+
+    def heading=(angle)
+      @heading = normalize_angle(angle)
+    end
+
+    def gun_heading=(angle)
+      @gun_heading = normalize_angle(angle)
+    end
+
+    def radar_heading=(angle)
+      @radar_heading = normalize_angle(angle)
+    end
+
+    def normalize_angle(angle)
+      angle % 360
+    end
+
+    def tick_events
+      { scanned_robots: scan }
+    end
+
+    def new_bullet
+      Bullet.new(x: x, y: y, heading: gun_heading, arena: arena, origin: self)
+    end
+
+    def robot_in_radar_view?(robot)
+      angle_diff(radar_heading, enemy_angle(robot)).abs <= radar_view_angle/2
+    end
+
+    def enemy_angle(robot)
+      Gosu.angle(x, y, robot.x, robot.y)
+    end
+
+    def angle_diff(angle1, angle2)
+      Gosu.angle_diff(angle1, angle2)
+    end
+
+    def other_robots
+      arena.robots.find_all { |robot| robot != self }
+    end
+
+    def fix_position
+      @x = min_x if x < min_x
+      @x = max_x if x > max_x
+      @y = min_y if y < min_y
+      @y = max_y if y > max_y
+    end
+
+    def min_x
+      size/2
+    end
+
+    def max_x
+      arena.width - min_x
+    end
+
+    def min_y
+      size/2
+    end
+
+    def max_y
+      arena.height - min_y
+    end
+
+    def sanitize_maximum_value(number, maximum_change)
+      ValueSanitizer.sanitize(number, maximum_change)
+    end
+  end
+end

data/lib/ruby_arena/robot_renderer.rb

@@ -0,0 +1,180 @@
+module RubyArena
+  class RobotRenderer
+    attr_reader :robot, :window
+
+    def initialize(args)
+      @robot = args.fetch(:robot)
+      @window = args.fetch(:window)
+    end
+
+    def draw
+      draw_tank_body
+      draw_gun
+      draw_radar
+    end
+
+    private
+
+    def draw_tank_body
+      window.rotate(heading, x, y) do
+        window.draw_quad(
+          x1, y1, color,
+          x2, y1, color,
+          x2, y2, color,
+          x1, y2, color
+        )
+      end
+    end
+
+    def x
+      robot.x
+    end
+
+    def y
+      robot.y
+    end
+
+    def x1
+      x - size/2
+    end
+
+    def x2
+      x + size/2
+    end
+
+    def y1
+      y - size/2
+    end
+
+    def y2
+      y + size/2
+    end
+
+    def size
+      robot.size
+    end
+
+    def heading
+      robot.heading
+    end
+
+    def color
+      Gosu::Color::WHITE
+    end
+
+    def draw_radar
+      color = Gosu::Color.new(40, 0, 255, 0)
+
+      window.draw_triangle(
+        x, y, color,
+        radar_x1, radar_y1, color,
+        radar_x2, radar_y2, color
+      )
+
+      window.rotate(radar_heading, x, y) do
+        window.draw_triangle(
+          radar_base_x1, y, color,
+          radar_base_x2, y, color,
+          x, radar_base_y3, color
+        )
+      end
+    end
+
+    def radar_x1
+      x + Gosu.offset_x(radar_heading - radar_view_angle / 2, radar_range)
+    end
+
+    def radar_x2
+      x + Gosu.offset_x(radar_heading + radar_view_angle / 2, radar_range)
+    end
+
+    def radar_y1
+      y + Gosu.offset_y(radar_heading - radar_view_angle / 2, radar_range)
+    end
+
+    def radar_y2
+      y + Gosu.offset_y(radar_heading + radar_view_angle / 2, radar_range)
+    end
+
+    def radar_base_x1
+      x + 4
+    end
+
+    def radar_base_x2
+      x - 4
+    end
+
+    def radar_base_y3
+      y + 6
+    end
+
+    def radar_heading
+      robot.radar_heading
+    end
+
+    def radar_view_angle
+      robot.radar_view_angle
+    end
+
+    def radar_range
+      robot.radar_range
+    end
+
+    def draw_gun
+      window.rotate(gun_heading, x, y) do
+        window.draw_quad(
+          gun_x1, gun_y1, gun_color,
+          gun_x2, gun_y1, gun_color,
+          gun_x2, gun_y2, gun_color,
+          gun_x1, gun_y2, gun_color
+        )
+        window.draw_quad(
+          gun_base_x1, gun_base_y1, gun_color,
+          gun_base_x2, gun_base_y1, gun_color,
+          gun_base_x2, gun_base_y2, gun_color,
+          gun_base_x1, gun_base_y2, gun_color
+        )
+      end
+    end
+
+    def gun_x1
+      x - 2
+    end
+
+    def gun_x2
+      x + 2
+    end
+
+    def gun_y1
+      y - size/1.5
+    end
+
+    def gun_y2
+      y
+    end
+
+    def gun_base_x1
+      x - size/4
+    end
+
+    def gun_base_x2
+      x + size/4
+    end
+
+    def gun_base_y1
+      y - size/4
+    end
+
+    def gun_base_y2
+      y + size/4
+    end
+
+    def gun_heading
+      robot.gun_heading
+    end
+
+    def gun_color
+      Gosu::Color::GRAY
+    end
+  end
+end

data/lib/ruby_arena/value_sanitizer.rb

@@ -0,0 +1,11 @@
+module RubyArena
+  class ValueSanitizer
+    def self.sanitize(value, maximum_allowed_change)
+      if value.abs <= maximum_allowed_change
+        value
+      else
+        value < 0 ? -maximum_allowed_change : maximum_allowed_change
+      end
+    end
+  end
+end

data/lib/ruby_arena/version.rb

@@ -0,0 +1,3 @@
+module RubyArena
+  VERSION = "0.0.2"
+end

data/lib/ruby_arena.rb

@@ -0,0 +1,23 @@
+require 'gosu'
+require 'optparse'
+
+require 'ruby_arena/ai'
+require 'ruby_arena/arena'
+require 'ruby_arena/bullet_renderer'
+require 'ruby_arena/class_loader'
+require 'ruby_arena/command_parser'
+require 'ruby_arena/gui'
+require 'ruby_arena/value_sanitizer'
+require 'ruby_arena/movable'
+require 'ruby_arena/robot'
+require 'ruby_arena/level0'
+require 'ruby_arena/level1'
+require 'ruby_arena/level'
+require 'ruby_arena/game'
+require 'ruby_arena/bullet'
+require 'ruby_arena/option_parser'
+require 'ruby_arena/robot_renderer'
+require "ruby_arena/version"
+
+module RubyArena
+end

data/ruby_arena.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_arena/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby_arena"
+  spec.version       = RubyArena::VERSION
+  spec.authors       = ["Patrik Bóna"]
+  spec.email         = ["hello@mrhead.sk"]
+  spec.summary       = %q{Ruby Arena for fights between robots with own AI.}
+  spec.description   = %q{Ruby Arena for fights between robots with own AI.}
+  spec.homepage      = "https://github.com/mrhead/ruby_arena"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "gosu"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta1"
+end

data/spec/ai_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe RubyArena:: Ai do
+  describe '#tick' do
+    it 'raises NotImplementedError' do
+      ai = RubyArena::Ai.new(robot: nil, command_parser: nil)
+
+      expect { ai.tick }.to raise_error NotImplementedError
+    end
+  end
+end

data/spec/ai_test.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+class AiTest
+  def initialize(args = {})
+
+  end
+
+  def tick
+    puts '#tick!'
+  end
+end

data/spec/arena_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe RubyArena:: Arena do
+  describe '#add_robot' do
+    it 'adds new robot' do
+      arena.add_robot(:robot)
+
+      expect(arena.robots).to eq [:robot]
+    end
+  end
+
+  describe '#add_bullet' do
+    it 'adds new robot' do
+      arena.add_bullet(:bullet)
+
+      expect(arena.bullets).to eq [:bullet]
+    end
+  end
+
+  describe '#update' do
+    it 'calls #tick on all robots and then #update on all robots' do
+      arena.add_robot(robot)
+
+      expect(robot).to receive(:tick)
+      expect(robot).to receive(:update)
+
+      arena.update
+    end
+
+    it 'removes robot if it is dead' do
+      robot = robot(dead?: true)
+
+      arena.add_robot(robot)
+      arena.update
+
+      expect(arena.robots).to eq []
+    end
+
+    it 'removes bullet if it is dead' do
+      bullet = robot(dead?: true)
+
+      arena.add_bullet(bullet)
+      arena.update
+
+      expect(arena.bullets).to eq []
+    end
+
+    it 'increases time by 1' do
+      arena.update
+
+      expect(arena.time).to be 1
+    end
+  end
+
+  describe '#game_over?' do
+    it 'returns false with empty arena' do
+      expect(arena.game_over?).to be false
+    end
+
+    it 'returns true if number of alive robots drops to 1 and less' do
+      robot1 = double('robot1', dead?: false, tick: nil, update: nil)
+      robot2 = double('robot2', dead?: true, tick: nil, update: nil)
+
+      arena.add_robot(robot1)
+      arena.add_robot(robot2)
+      arena.update
+
+      expect(arena.game_over?). to be true
+    end
+  end
+
+  def arena
+    @_arena ||= RubyArena::Arena.new
+  end
+
+  def robot(args = {})
+    @_robot ||= double('robot', tick: nil, dead?: args[:dead?], update: nil)
+  end
+end

data/spec/bullet_renderer_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe RubyArena:: BulletRenderer do
+end

data/spec/bullet_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe RubyArena:: Bullet do
+  it_behaves_like 'movable'
+
+  describe '#intersect?' do
+    it 'returns true if given object intersects bullet' do
+      robot = double('robot', x: 10, y: 10, size: 30)
+      bullet = bullet(x: 0, y: 0)
+
+      expect(bullet.intersect?(robot)).to be true
+    end
+
+    it 'returns false if given object doesnt intersect bullet' do
+      robot = double('robot', x: 100, y: 10, size: 30)
+      bullet = bullet(x: 0, y: 0)
+
+      expect(bullet.intersect?(robot)).to be false
+    end
+  end
+
+  def object(args = {})
+    bullet(args)
+  end
+
+  def bullet(args = {})
+    defaults = {
+      x: 0,
+      y: 0,
+      heading: 0,
+      arena: nil,
+      origin: nil
+    }
+    @_bullet ||= RubyArena::Bullet.new(defaults.merge(args))
+  end
+end

data/spec/class_loader_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe RubyArena:: ClassLoader do
+  describe '#class_from_file' do
+    it 'returns class loaded from a file' do
+      file = File.dirname(__FILE__) + '/ai_test.rb'
+      class_loader = RubyArena::ClassLoader.new(file)
+
+      klass = class_loader.get_class
+
+      expect(klass).to be AiTest
+    end
+  end
+end