rubots 0.1

data/bin/rubots

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rubots'
+
+Rubots.run_game ARGV

data/lib/rubots.rb

@@ -0,0 +1,17 @@
+require 'gosu'
+require 'rubots/graphics'
+require 'rubots/game'
+require 'rubots/robot'
+require 'rubots/command'
+require 'rubots/beam'
+require 'rubots/strategy'
+require 'rubots/strategy_loader'
+require 'rubots/samples'
+
+module Rubots
+  def self.run_game(params)
+    game = Game.new StrategyLoader.load(params)
+
+    Graphics::Window.new(game).show
+  end
+end

data/lib/rubots/beam.rb

@@ -0,0 +1,48 @@
+module Rubots
+  class Beam
+    attr_reader :source_x, :source_y, :angle
+
+    def initialize(source_x, source_y, angle)
+      @source_x = source_x
+      @source_y = source_y
+      @angle = angle
+    end
+
+    def self.from(robot)
+      real_angle = (robot.angle + robot.gun_angle) % 360
+      new robot.x, robot.y, real_angle
+    end
+
+    def check_hit(robot)
+      if found_hit?(robot)
+        robot.destroy
+        puts "#{robot.name} hit by laser"
+      end
+    end
+
+    # Laser beam is:
+    # (x - x0) = tan(angle)(y0 - y)
+    # We check for X:
+    # x = tan(angle)(y0 - y) + x0
+    # We check for Y
+    # y = (x0 - x)/tan(angle) - y0
+    HIT_THRESHOLD = 16
+    def found_hit?(robot)
+      return false if robot.x == @source_x && robot.y == @source_y # Avoid hitting self
+
+      # Check we're pointing to the right quadrant
+      return false if robot.x > @source_x && (@angle > 190 && @angle < 350)
+      return false if robot.x < @source_x && (@angle < 170 && @angle >  10)
+      return false if robot.y > @source_y && (@angle > 280 || @angle <  80)
+      return false if robot.y < @source_y && (@angle < 260 && @angle > 100)
+
+      tan_angle = Math.tan(@angle * Math::PI / 180)
+
+      test_x = tan_angle * (@source_y - robot.y) + @source_x
+      return true if (test_x - robot.x).abs < HIT_THRESHOLD
+
+      test_y = (@source_x - robot.x)/tan_angle - @source_y
+      (test_y - robot.y).abs < HIT_THRESHOLD
+    end
+  end
+end

data/lib/rubots/command.rb

@@ -0,0 +1,6 @@
+require 'rubots/command/base'
+require 'rubots/command/rotate_to'
+require 'rubots/command/throttle'
+require 'rubots/command/rotate_gun_to'
+require 'rubots/command/fire'
+require 'rubots/command/do_nothing'

data/lib/rubots/command/base.rb

@@ -0,0 +1,10 @@
+module Rubots
+  module Command
+    class Base
+      def cooldown
+        0
+      end
+    end
+  end
+end
+

data/lib/rubots/command/do_nothing.rb

@@ -0,0 +1,10 @@
+module Rubots
+  module Command
+    class DoNothing < Base
+      def apply_to(robot)
+        # Nothing
+      end
+    end
+  end
+end
+

data/lib/rubots/command/fire.rb

@@ -0,0 +1,13 @@
+module Rubots
+  module Command
+    class Fire < Base
+      def apply_to(robot)
+        robot.do_fire
+      end
+
+      def cooldown
+        60
+      end
+    end
+  end
+end

data/lib/rubots/command/rotate_gun_to.rb

@@ -0,0 +1,14 @@
+module Rubots
+  module Command
+    class RotateGunTo < Base
+      def initialize(angle)
+        @angle = angle % Robot::MAX_GUN_ANGLE
+      end
+
+      def apply_to(robot)
+        robot.desired_gun_angle = @angle
+      end
+    end
+  end
+end
+

data/lib/rubots/command/rotate_to.rb

@@ -0,0 +1,13 @@
+module Rubots
+  module Command
+    class RotateTo < Base
+      def initialize(angle)
+        @angle = angle % Robot::MAX_ANGLE
+      end
+
+      def apply_to(robot)
+        robot.desired_angle = @angle
+      end
+    end
+  end
+end

data/lib/rubots/command/throttle.rb

@@ -0,0 +1,19 @@
+module Rubots
+  module Command
+    class Throttle
+      def initialize(throttle)
+        @throttle = throttle
+        @throttle = 0 if @throttle < 0
+        @throttle = Robot::MAX_THROTTLE if @throttle > Robot::MAX_THROTTLE
+      end
+
+      def apply_to(robot)
+        robot.desired_throttle = @throttle
+      end
+
+      def cooldown
+        5
+      end
+    end
+  end
+end

data/lib/rubots/game.rb

@@ -0,0 +1,81 @@
+module Rubots
+  class Game
+    attr_reader :robots, :laser_beams
+    MAP_HEIGHT = 700
+    MAP_WIDTH  = 1000
+
+    def initialize(robots)
+      @robots = robots.map { |klass| Robot.new(klass, self, *random_location) }
+    end
+
+    def tick
+      @laser_beams = []
+      @robots.each { |robot| robot.tick      }
+      @robots.each { |robot| robot.tick_fire }
+      check_collisions
+      check_out_of_area
+      check_beam_hits
+      clean_up_bodies
+    end
+
+    def map
+      OpenStruct.new width: MAP_WIDTH, height: MAP_HEIGHT
+    end
+
+    def laser_fire(beam)
+      @laser_beams << beam
+    end
+
+    def over?
+      @robots.count <= 1
+    end
+
+    def winner
+      return nil unless over?
+
+      @robots.first || OpenStruct.new(name: "Nobody")
+    end
+
+  private
+
+    # TODO enforce separation
+    def random_location
+      x = rand(MAP_WIDTH)
+      y = rand(MAP_HEIGHT)
+      [x, y]
+    end
+
+    COLLISION_DISTANCE = 32
+    def check_collisions
+      @robots.each do |r1|
+        @robots.each do |r2|
+          next if r1 == r2
+          if r1.distance_to(r2) < COLLISION_DISTANCE
+            r1.destroy
+            puts "#{r1.name} destroyed by collision with #{r2.name}"
+          end
+        end
+      end
+    end
+
+    def check_beam_hits
+      @laser_beams.each do |beam|
+        @robots.each { |robot| beam.check_hit robot }
+      end
+    end
+
+    def check_out_of_area
+      @robots.each do |r|
+        if r.x > MAP_WIDTH || r.y > MAP_HEIGHT || r.x < 0 || r.y < 0
+          r.destroy
+          puts "#{r.name} hit the invisible wall and was destroyed"
+        end
+      end
+    end
+
+    def clean_up_bodies
+      @robots.reject!(&:destroyed?)
+    end
+
+  end
+end

data/lib/rubots/graphics.rb

@@ -0,0 +1,4 @@
+require 'rubots/graphics/window'
+require 'rubots/graphics/robot'
+require 'rubots/graphics/beam'
+require 'rubots/graphics/assets'

data/lib/rubots/graphics/assets.rb

@@ -0,0 +1,11 @@
+module Rubots
+  module Graphics
+    class Assets
+      MEDIA_DIR = File.join(File.dirname(__FILE__), '..', '..', '..', 'media')
+      PEW_SOUND = File.join(MEDIA_DIR, "pew.wav")
+      ROBOT_IMG = File.join(MEDIA_DIR, "robot.png")
+      GUN_IMG   = File.join(MEDIA_DIR, "gun.png")
+      DEAD_IMG  = File.join(MEDIA_DIR, "deadbot.png")
+    end
+  end
+end

data/lib/rubots/graphics/beam.rb

@@ -0,0 +1,32 @@
+module Rubots
+  module Graphics
+    class Beam
+      BEAM_LENGTH = 10000 # As long as it goes out of the screen it's good
+      BEAM_DURATION = 30 # For how many ticks is the beam visible
+
+      def initialize(window, beam)
+        @beam = beam
+        @duration = BEAM_DURATION
+        @window = window
+        @pew = Gosu::Sample.new(window, Assets::PEW_SOUND)
+        @pew.play
+      end
+
+      def decay
+        @duration -= 1
+      end
+
+      def expired?
+        @duration <= 0
+      end
+
+      def draw
+        rad_angle = @beam.angle * Math::PI / 180
+        x_end = @beam.source_x + Math.sin(rad_angle) * BEAM_LENGTH
+        y_end = @beam.source_y + Math.cos(rad_angle) * BEAM_LENGTH * -1
+        beam_color = 0xffff0000
+        @window.draw_line @beam.source_x, @beam.source_y, beam_color, x_end, y_end, beam_color
+      end
+    end
+  end
+end

data/lib/rubots/graphics/robot.rb

@@ -0,0 +1,25 @@
+module Rubots
+  module Graphics
+    class Robot
+      Z_AXIS = 10
+
+      def initialize(window, robot)
+        @robot = robot
+        @image      = Gosu::Image.new(window, Assets::ROBOT_IMG, false)
+        @gun_image  = Gosu::Image.new(window, Assets::GUN_IMG, false)
+        @dead_image = Gosu::Image.new(window, Assets::DEAD_IMG, false)
+        @font       = Gosu::Font.new(window, Gosu::default_font_name, 14)
+      end
+
+      def draw
+        if @robot.destroyed?
+          @dead_image.draw_rot(@robot.x, @robot.y, Z_AXIS, 0)
+        else
+          @image.draw_rot(@robot.x, @robot.y, Z_AXIS, @robot.angle)
+          @gun_image.draw_rot(@robot.x, @robot.y, Z_AXIS + 1, @robot.angle + @robot.gun_angle)
+        end
+        @font.draw_rel(@robot.name, @robot.x, @robot.y + 20, Z_AXIS + 2, 0.5, 1.0, 1.0, 1.0, 0xffffff00)
+      end
+    end
+  end
+end

data/lib/rubots/graphics/window.rb

@@ -0,0 +1,43 @@
+module Rubots
+  module Graphics
+    class Window < Gosu::Window
+      def initialize(game)
+        @game = game
+        super Game::MAP_WIDTH, Game::MAP_HEIGHT, false
+        self.caption = "LASER RUBOTS PEW PEW PEW"
+        @robots = @game.robots.map { |r| Robot.new self, r }
+        @beams = []
+      end
+
+      GAME_END_TICKS = 150
+      def update
+        if !@game_over
+          @game.tick
+          @beams += @game.laser_beams.map { |b| Beam.new self, b }
+          decay_beams
+          @game_over = @game.over?
+        else
+          @game_over_countdown ||= GAME_END_TICKS
+          @game_over_countdown -= 1
+          if @game_over_countdown == 0
+            puts "#{@game.winner.name} wins the game."
+            exit
+          end
+        end
+
+      end
+
+      def draw
+        @robots.each &:draw
+        @beams.each &:draw
+      end
+
+    private
+
+      def decay_beams
+        @beams.each(&:decay)
+        @beams.reject!(&:expired?)
+      end
+    end
+  end
+end

data/lib/rubots/robot.rb

@@ -0,0 +1,152 @@
+require 'ostruct'
+
+module Rubots
+  class Robot
+    attr_reader :x, :y, :angle, :gun_angle
+    attr_writer :desired_angle, :desired_throttle, :desired_gun_angle
+
+    # Some constants
+    MAX_ANGLE      = 360 # Maximum angle. Wraps around to zero after this.
+    ANGLE_STEP     = 1   # How much we change angle each tick.
+
+    MAX_THROTTLE   = 10  # Max throttle. Can't go above.
+    THROTTLE_STEP  = 1   # How much we change throttle each tick.
+
+    SPEED_FACTOR   = 1   # How much movement does each throttle step represent
+
+    MAX_GUN_ANGLE  = 360 # Maximum gun angle. Wraps around to zero after this.
+    GUN_ANGLE_STEP = 2   # How much we change angle each tick.
+
+
+    def initialize(strategy_class, game, x, y)
+      @x = x
+      @y = y
+      @throttle  = @desired_throttle  = 0.0
+      @angle     = @desired_angle     = 0.0
+      @gun_angle = @desired_gun_angle = 0.0
+      @game = game
+
+      @strategy = strategy_class.new(@game.map, robot_data, nil)
+
+      @destroyed = false
+
+      @cooldown_timer = 0
+    end
+
+    def tick
+      return if @destroyed
+
+      if @cooldown_timer > 0
+        @cooldown_timer -= 1
+      else
+        command = @strategy.get_command(robot_data, targets_data)
+        command.apply_to(self)
+        @cooldown_timer = command.cooldown
+      end
+      tick_angle
+      tick_throttle
+      tick_movement
+      tick_gun
+    end
+
+    # It's a separate method because we want fire to be after *every* robot moved
+    def tick_fire
+      if @firing
+        @game.laser_fire(Beam.from(self))
+        @firing = false
+      end
+    end
+
+    def name
+      @strategy.name
+    end
+
+    def do_fire
+      @firing = true
+    end
+
+    def distance_to(other)
+      x_dist = @x - other.x
+      y_dist = @y - other.y
+      Math.sqrt(x_dist ** 2 + y_dist ** 2)
+    end
+
+    def destroy
+      @throttle = 0
+      @destroyed = true
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+  private
+
+    def robot_data
+      OpenStruct.new x: @x, y: @y, angle: @angle, throttle: @throttle, gun_angle: @gun_angle
+    end
+
+    def targets_data
+      @game.robots.map do |target_robot|
+        next if target_robot == self
+        x_dist = @x - target_robot.x
+        y_dist = @y - target_robot.y
+        distance = Math.sqrt(x_dist ** 2 + y_dist ** 2)
+        actual_angle = Math.atan2(x_dist, -y_dist) * 180 / Math::PI + 180
+        relative_angle = (actual_angle - @angle) % 360
+
+        OpenStruct.new name: target_robot.name, distance: distance, angle: relative_angle
+      end.compact
+    end
+
+    def tick_angle
+      if @desired_angle != @angle
+        if (@desired_angle - @angle).abs < ANGLE_STEP
+          @angle = @desired_angle # Fractional angles
+        else
+          diff = @desired_angle - @angle
+          sign = diff / diff.abs
+          sign = sign * -1 if diff.abs > MAX_ANGLE / 2.0
+          @angle += sign * ANGLE_STEP
+          @angle += MAX_ANGLE if @angle < 0
+          @angle -= MAX_ANGLE if @angle >= MAX_ANGLE
+        end
+      end
+    end
+
+    def tick_throttle
+      if @desired_throttle != @throttle
+        diff = @desired_throttle - @throttle
+        if diff.abs < THROTTLE_STEP
+          @throttle = @desired_throttle
+        else
+          @throttle += (diff / diff.abs) * THROTTLE_STEP
+        end
+      end
+    end
+
+    def tick_movement
+      movement = @throttle * SPEED_FACTOR
+      rad_angle = angle * Math::PI / 180
+      mov_x = Math.sin(rad_angle) * movement
+      mov_y = Math.cos(rad_angle) * movement * -1
+      @x += mov_x
+      @y += mov_y
+    end
+
+    def tick_gun
+      if @desired_gun_angle != @gun_angle
+        if (@desired_gun_angle - @gun_angle).abs < GUN_ANGLE_STEP
+          @gun_angle = @desired_gun_angle # Fractional angles
+        else
+          diff = @desired_gun_angle - @gun_angle
+          sign = diff / diff.abs
+          sign = sign * -1 if diff.abs > MAX_GUN_ANGLE / 2.0
+          @gun_angle += sign * GUN_ANGLE_STEP
+          @gun_angle += MAX_GUN_ANGLE if @gun_angle < 0
+          @gun_angle -= MAX_GUN_ANGLE if @gun_angle >= MAX_GUN_ANGLE
+        end
+      end
+    end
+  end
+end

data/lib/rubots/samples.rb

@@ -0,0 +1,4 @@
+require 'rubots/samples/sitting_duck'
+require 'rubots/samples/rotator'
+require 'rubots/samples/target_finder'
+require 'rubots/samples/artillery'

data/lib/rubots/samples/artillery.rb

@@ -0,0 +1,24 @@
+module Rubots
+  module Samples
+    # Points at a target and fires a single shot.
+    class Artillery < Strategy
+      def initialize(map, me, targets)
+        @fired = false
+      end
+
+      def command(me, targets)
+        if me.angle != 90
+          rotate_to 90
+        elsif me.gun_angle != targets.first.angle
+          rotate_gun_to targets.first.angle
+        else
+          fire
+        end
+      end
+
+      def name
+        "Artillery"
+      end
+    end
+  end
+end

data/lib/rubots/samples/rotator.rb

@@ -0,0 +1,24 @@
+module Rubots
+  module Samples
+    # Rotates in place direction
+    class Rotator < Strategy
+      def initialize(map, me, targets)
+        @direction = :left
+      end
+
+      def command(me, targets)
+        if @direction == :left
+          @direction = :right if me.angle == 270
+          rotate_to 270
+        else
+          @direction = :left if me.angle == 89
+          rotate_to 89
+        end
+      end
+
+      def name
+        "Rotator"
+      end
+    end
+  end
+end

data/lib/rubots/samples/sitting_duck.rb

@@ -0,0 +1,11 @@
+module Rubots
+  module Samples
+    # Just stays there
+    class SittingDuck < Strategy
+
+      def name
+        "Duck"
+      end
+    end
+  end
+end

data/lib/rubots/samples/target_finder.rb

@@ -0,0 +1,68 @@
+module Rubots
+  module Samples
+    # Homes into the center of the map, then stays there, points up, and aims down.
+    class TargetFinder < Strategy
+      ANGLE_DOWN  = 180
+      ANGLE_UP    = 0
+      ANGLE_LEFT  = 270
+      ANGLE_RIGHT = 90
+
+      def initialize(map, me, targets)
+        @finding = :x
+        @map = map
+        @find_x = map.width / 2
+        @find_y = map.height / 2
+      end
+
+      def command(me, targets)
+        if @finding == :x
+          find_x(me)
+        elsif @finding == :y
+          find_y(me)
+        elsif me.angle != 0
+          rotate_to 0
+        else
+          rotate_gun_to 180
+        end
+      end
+
+      def name
+        "GoToCenter"
+      end
+
+      def find_x(me)
+        if me.x > @find_x && me.angle != ANGLE_LEFT
+          rotate_to ANGLE_LEFT
+        elsif me.x < @find_x && me.angle != ANGLE_RIGHT
+          rotate_to ANGLE_RIGHT
+        elsif me.x != @find_x
+          if (@find_x - me.x).abs > 50
+            throttle 4
+          else
+            throttle 1
+          end
+        else # At pos x
+          @finding = :y
+          throttle 0
+        end
+      end
+
+      def find_y(me)
+        if me.y > @find_y && me.angle != ANGLE_UP
+          rotate_to ANGLE_UP
+        elsif me.y < @find_y && me.angle != ANGLE_DOWN
+          rotate_to ANGLE_DOWN
+        elsif me.y != @find_y
+          if (@find_y - me.y).abs > 50
+            throttle 5
+          else
+            throttle 1
+          end
+        else # At pos y
+          @finding = :none
+          throttle 0
+        end
+      end
+    end
+  end
+end

data/lib/rubots/strategy.rb

@@ -0,0 +1,44 @@
+module Rubots
+  class Strategy
+    def initialize(map, me, targets)
+    end
+
+    # Called by the Robot to get a command
+    def get_command(me, targets)
+      @command_queue ||= []
+      command(me, targets) if @command_queue.empty?
+      @command_queue.shift || Command::DoNothing.new
+    end
+
+    # When get_command is out of commands, it calls this, which will queue commands
+    def command(me, targets)
+      # Implement in subclass
+    end
+
+    def name
+      "Unnamed robot"
+    end
+
+    protected
+
+    def rotate_to(angle)
+      @command_queue << Command::RotateTo.new(angle)
+    end
+
+    def rotate_gun_to(angle)
+      @command_queue << Command::RotateGunTo.new(angle)
+    end
+
+    def throttle(throttle)
+      @command_queue << Command::Throttle.new(throttle)
+    end
+
+    def fire
+      @command_queue << Command::Fire.new
+    end
+
+    def do_nothing
+      @command_queue << Command::DoNothing.new
+    end
+  end
+end

data/lib/rubots/strategy_loader.rb

@@ -0,0 +1,51 @@
+module Rubots
+  class StrategyLoader
+    def self.load(params)
+      return default_lineup unless params.any?
+
+      params.map { |p| new(p).strategy_class }
+    end
+
+    def self.default_lineup
+      [ Samples::Rotator, Samples::SittingDuck, Samples::TargetFinder,
+        Samples::Artillery ]
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def strategy_class
+      if is_sample?
+        sample_class
+      else
+        class_from_file
+      end
+    end
+
+  private
+
+    def class_from_file
+      load @name
+
+      class_name = camelize(File.basename(@name, ".rb"))
+      Rubots.const_get(class_name)
+    end
+
+    def is_sample?
+      @name.match /^sample:/
+    end
+
+    def sample_class
+      Samples.const_get(camelize(@name.split(':').last))
+    end
+
+    def camelize(term)
+      string = term.to_s
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string.gsub!('/', '::')
+      string
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: rubots
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Nacho Facello
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.50
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.50
+description: A small simple game where you program robots to fight to the death using
+  red lasers
+email: nacho@nucleartesuji.com
+executables:
+- rubots
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rubots/samples.rb
+- lib/rubots/graphics.rb
+- lib/rubots/game.rb
+- lib/rubots/beam.rb
+- lib/rubots/command/rotate_gun_to.rb
+- lib/rubots/command/throttle.rb
+- lib/rubots/command/do_nothing.rb
+- lib/rubots/command/rotate_to.rb
+- lib/rubots/command/fire.rb
+- lib/rubots/command/base.rb
+- lib/rubots/strategy.rb
+- lib/rubots/strategy_loader.rb
+- lib/rubots/robot.rb
+- lib/rubots/graphics/assets.rb
+- lib/rubots/graphics/beam.rb
+- lib/rubots/graphics/robot.rb
+- lib/rubots/graphics/window.rb
+- lib/rubots/samples/sitting_duck.rb
+- lib/rubots/samples/rotator.rb
+- lib/rubots/samples/artillery.rb
+- lib/rubots/samples/target_finder.rb
+- lib/rubots/command.rb
+- lib/rubots.rb
+- media/deadbot.png
+- media/gun.png
+- media/robot.png
+- media/pew.wav
+- bin/rubots
+homepage: http://github.com/nachof/laser_rubots
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Laser Rubots!
+test_files: []