UG_RRobots 1.2

data/robots/RoomPainter.rb

@@ -0,0 +1,205 @@
+# RoomPainter
+# written by Jannis Harder (jix) in 2005
+
+require 'robot'
+
+# avoid clashes with other state robots
+
+module RoomPainterTools
+
+  # a state based robot
+  class StateRobot
+    include Robot
+    
+    def initialize(*)
+      super
+      @mode = :idle
+      @sec_modes = []
+      init
+    end
+    
+    # set mode for next tick
+    def next_mode new_mode
+      if has_mode? new_mode
+        @mode = new_mode
+      else
+        warn "Robot #{self.class} switched to unknown mode :#{new_mode}!"
+        @mode = :idle
+      end
+    end
+    
+    # activate a secondary mode
+    def add_sec_mode new_mode
+      if has_mode? new_mode
+        @sec_modes << new_mode
+      else
+        warn "Robot #{self.class} switched to unknown secondary mode :#{new_mode}!"
+      end
+    end
+    
+    # activate some secondary modes
+    def add_sec_modes *modes
+      modes.flatten.each do |new_mode|
+        add_sec_mode new_mode
+      end
+    end
+    
+    # deactivate a secondary mode
+    def del_sec_mode old_mode
+      @sec_modes.delete old_mode
+    end
+    
+    # deactivate some secondary modes
+    def del_sec_modes *modes
+      modes.flatten.each do |old_mode|
+        del_sec_mode old_mode
+      end
+    end
+    
+    # test for a mode
+    def has_mode? new_mode
+      respond_to? new_mode.to_s<<'_tick'
+    end
+    
+    # set new mode and tick it once
+    def mode new_mode
+      next_mode new_mode
+      tick @events
+    end
+    
+    # tick a mode
+    def tick_mode temp_mode
+      send temp_mode.to_s<<'_tick'
+    end
+    
+    # default tick
+    def idle_tick 
+    end
+    
+    # processing
+    def tick events
+      @events = events
+      tick_mode @mode
+      @sec_modes.each do |smode|
+        tick_mode smode
+      end
+    end
+    
+    
+    attr_reader :events
+    
+  end
+  
+end
+
+class RoomPainter < RoomPainterTools::StateRobot
+
+  def init
+    next_mode :move
+    add_sec_modes :aim, :scan, :fire
+    @scan_range = 2
+    @tracking = 0
+    @fire = [nil]*2
+    @turning = 0
+    @deg = 0
+    @acc = 1
+  end
+  
+
+  #helpers
+  
+  def offset(heading_a,heading_b)
+    my_offset = heading_a-heading_b % 360
+    my_offset = my_offset -360 if my_offset > 180
+    my_offset
+  end
+  
+  def on_wall
+    x <= size or \
+    y <= size or \
+    x >= battlefield_width-size or \
+    y >= battlefield_height-size
+  end
+  
+  def nth?(n)
+    time % n == 0
+  end
+  
+  #ticks 
+  
+  def turn_upwards_tick
+    stop
+    if heading == 90
+      mode :paint
+      
+    else
+      turn 90-heading
+    end
+  end
+  
+  def scan_tick
+    @scan_range = [@scan_range,10].min
+
+    radar_offset = offset(radar_heading,gun_heading)
+    if nth? 2
+      turn_radar -@scan_range-radar_offset
+    else
+      turn_radar +@scan_range-radar_offset
+    end
+  end
+  
+  def fire_tick
+    if x = @fire.pop
+      fire x
+    end
+    if scanned = events['robot_scanned'].first
+      away = scanned.first
+      str = [0.1,800.0/away].max
+      @fire << str
+    else
+      @fire << nil
+    end
+
+  end
+  
+  def aim_tick
+    
+    if scanned = events['robot_scanned'].first
+      away = scanned.first
+      @scan_range = 1.2
+      
+      @last_offset = offset(radar_heading,gun_heading)/2.0
+      turn_gun(@last_offset)
+      @tracking = 10
+    elsif @tracking <= 0
+      @scan_range += 0.1
+      if @deg > 0
+        turn_gun(-30)
+      else
+        turn_gun(30)
+      end
+    else
+      @tracking-=1
+      @last_offset*=-2
+      turn_gun(@last_offset)
+    end
+    
+  end
+  
+  def move_tick
+    accelerate(@acc)
+    if @turning <= 0
+      @turning = rand(30)
+      @deg = (rand*4)*(1-rand(2)*2)
+    end
+    @turning-=1
+    if on_wall and (velocity < 0) == (@acc < 0) and velocity.abs > 4
+      @acc *= -1
+    else
+      turn(@deg)
+    end
+  end
+  
+
+  
+end

data/robots/Rrrkele.rb

@@ -0,0 +1,48 @@
+require 'robot'
+
+class Rrrkele
+include Robot
+
+def limit value, m
+value -= 360 if value > 180
+value += 360 if value < -180
+value = -m if value < -m
+value = m if value > m
+return value
+end
+
+def tick events
+if time == 0
+@acc = 1
+@target_distance = 250
+@target_heading = rand * 360
+@scanning_range = 60
+@velocity = 0
+end
+
+unless events['robot_scanned'].empty?
+@target_distance = events["robot_scanned"].first.first
+@target_heading = @radar_heading
+@scanning_range *= -0.5 if @scanning_range.abs > 0.5
+else
+@scanning_range *= -2 if @scanning_range.abs < 60
+end
+
+unless events['got_hit'].empty?
+@acc *= -1
+end
+
+fire 0.1
+
+body_turn_angle = limit(@heading - @target_heading + 90, 10)
+gun_turn_angle = limit(@target_heading - @gun_heading - body_turn_angle, 30)
+radar_turn_angle = limit(@scanning_range - gun_turn_angle - body_turn_angle, 60)
+
+turn(body_turn_angle)
+turn_gun(gun_turn_angle)
+turn_radar(radar_turn_angle)
+
+accelerate(@acc)
+end
+end  
+

data/robots/Seeker.rb

@@ -0,0 +1,57 @@
+# follows and shoots
+require 'robot'
+
+class Seeker
+include Robot
+
+  attr_accessor
+
+  def initialize *args, &block
+    @rt = @radar_scan = 10
+    @min_radar_scan = 10.0
+    @max_radar_scan = 30.0
+    @radar_turned = false
+    @min_distance = 0
+    @direction = 1
+    super
+  end
+
+  def tick events
+    @direction = @min_distance - 175
+    accelerate(@direction)
+    wturn = 180 - ((radar_heading-heading)%360) + @rt*0.5
+    wturn = [-10,[10,wturn].min].max
+    turn wturn
+    scan events
+    turn_radar @rt - wturn
+    fire @direction > 0 ? 0.5 : 3.0
+  end
+
+  def scan events
+    if events['robot_scanned'].empty?
+      increase_radar_scan
+    else
+      decrease_radar_scan
+      @min_distance = events['robot_scanned'].min.first
+    end
+    @rt = if @radar_turned
+            -@radar_scan
+          else
+            @radar_scan
+          end if @radar_scan.abs < @max_radar_scan - 0.1
+    @radar_turned = !@radar_turned
+    @rt
+  end
+
+  def increase_radar_scan
+    @radar_scan *= 1.5
+    @radar_scan = [@radar_scan, @max_radar_scan].min
+  end
+
+  def decrease_radar_scan
+    @radar_scan *= 0.5
+    @radar_scan = [@radar_scan, @min_radar_scan].max
+  end
+
+end
+

data/robots/ShootingStation.rb

@@ -0,0 +1,15 @@
+require 'robot'
+class ShootingStation
+  include Robot
+  def tick events
+    if rand < 0.2
+      turn(10)
+      turn_gun(30)
+    else
+      turn(-4)
+      turn_gun(-30)
+    end
+    fire(0.3)
+    accelerate(1)
+  end
+end

data/robots/SittingDuck.rb

@@ -0,0 +1,18 @@
+require 'robot'
+
+class SittingDuck
+   include Robot
+
+  def tick events
+    turn_radar 5 if time == 0
+    fire 3 unless events['robot_scanned'].empty? 
+    turn_gun 10
+	
+	@last_hit = time unless events['got_hit'].empty? 
+	if @last_hit && time - @last_hit < 20
+      accelerate(1) 
+	else
+      stop	
+	end
+  end
+end

data/robots/SniperDuck.rb

@@ -0,0 +1,277 @@
+require 'robot'
+require 'matrix'
+
+
+class Numeric
+
+  def deg2rad
+    self * 0.0174532925199433
+  end
+
+  def rad2deg
+    self * 57.2957795130823
+  end
+
+end
+
+class Array
+  def average
+    inject{|s,i|s+i} / size.to_f
+  end
+  def sd
+    avg = average
+    Math.sqrt( inject(0){|s,i| s+(i-avg)**2} / (size-1.0) )
+  end
+end
+
+class Vector
+include Enumerable
+
+  def each &block
+    @elements.each(&block)
+  end
+
+end
+
+
+class SniperDuck
+include Robot
+
+  def initialize *args, &block
+    super
+    @rt = @radar_scan = 15
+    @min_radar_scan = 1.5
+    @max_radar_scan = 60.0
+    @radar_turned = false
+    @lock = false
+    @lock_threshold = 15.0
+    @firing_threshold = 20.0
+    @wanted_turn = @wanted_gun_turn = @wanted_radar_turn = 0
+    @rturn_dir = 1
+    @racc_dir = 1
+    @serial_hit_limit = 10
+    @serial_hit_counter = 0
+    @target_positions = []
+    @min_distance = 1500 
+    @sd_limit = 30
+  end
+
+  def tick events
+    @prev_health = energy if time == 0
+    scan events
+    firing_solution events
+    navigate events
+    turn_hull
+    turn_turret
+    turn_radar_dish
+    @prev_health = energy
+  end
+
+  def scan events
+    if events['robot_scanned'].empty?
+      increase_radar_scan
+      @lock = false
+    else
+      decrease_radar_scan
+      @lock = @radar_scan.abs < @lock_threshold
+    end
+    @rt = if @radar_turned
+            -@radar_scan
+          else
+            @radar_scan
+          end if @radar_scan.abs < @max_radar_scan - 0.1
+    @wanted_radar_turn += @rt
+    @radar_turned = !@radar_turned
+  end
+
+  def firing_solution events
+    add_target_position(events['robot_scanned'])
+    gtd = gun_target_distance
+    @firepower = [1.5e5 / (@min_distance)**2, 3*25 / (@vsd||1500)].max 
+    fire @firepower if @on_target
+    if @lock and gtd and gtd.abs < @firing_threshold
+      @wanted_gun_turn = gtd
+      @on_target = true
+    else
+      fire @firepower
+      @wanted_gun_turn = (gtd || (gun_radar_distance/3.0) + Math.sin(time*0.2)*(@vsd||50)/10)
+      @on_target = false
+    end
+  end
+
+  def add_target_position(distances)
+    unless distances.empty?
+      positions = distances.map{|d|
+        tx = x + Math.cos((radar_heading - @radar_scan.abs / 2.0).deg2rad) * d[0]
+        ty = y - Math.sin((radar_heading - @radar_scan.abs / 2.0).deg2rad) * d[0]
+        [d, Vector[tx,ty]]
+      }
+      last = @target_positions.last
+      position = if last
+        positions.min{|a,b| (a[1] - last).r <=> (b[1] - last).r }[1]
+      else
+        positions.min{|a,b| a[0] <=> b[0]}[1]
+      end
+      @min_distance = distances.min{|a,b| a[0]<=>b[0]}[0]
+      @target_positions.push position if position
+    end
+    @target_positions.shift if @target_positions.size > 200
+  end
+
+  def average_four_last_positions
+    c = 5
+    tps = @target_positions[-20,20]
+    ptas = (0...tps.size/c).map{|i| tps[i*c,c] }
+    ptas.map{|pta| average(pta) }
+  end
+
+  def average arr
+    arr.inject{|s,i| s+i} * (1.0/arr.size)
+  end
+
+  def sd arr
+    Math.sqrt(arr.map{|v| v[0]}.sd**2 + arr.map{|v| v[1]}.sd**2)
+  end
+
+  def gun_target_distance
+    return nil if @target_positions.size < 20
+    p1,p2,p3,p4 = average_four_last_positions
+    #p format([p1,p2,p3,p4].map{|i|i.to_a})
+    vs = [p1,p2,p3].zip([p2,p3,p4]).map{|a,b|b-a}
+    @vsd = sd vs
+    return nil if @vsd > @sd_limit
+    v = average(vs) * 0.2
+    return gun_radar_distance if v.r < 4.0
+    p4 = p4 + (v*3)
+    distance = p4 - Vector[x,y]
+    a = distance[0]**2 + distance[1]**2
+    b = 2*distance[0]*v[0] + 2*distance[1]*v[1]
+    c = v[0]**2 + v[1]**2
+    shot_speed = (30/8.0)*v.r
+    #p shot_speed
+    d = c - shot_speed**2
+    n = b**2 - 4*a*d
+    if n < 0
+      return nil
+    end
+    t = 2*a / (-b + Math.sqrt(n))
+    ep = p4 + v*t
+    estimated_position = Vector[[size, [battlefield_width-size, ep[0]].min].max, [size, [battlefield_height-size, ep[1]].min].max]
+    est_head = heading_for(estimated_position)
+    hd = heading_distance(gun_heading, est_head+rand*(@vsd-@vsd/2.0)/(distance.r/500))
+    #p format( [@target_positions.last, p4, v, [t], estimated_position, [est_head, gun_heading, hd]].map{|i|i.to_a} )
+    hd
+  end
+  
+  def format(arr, precision = 1)
+    case arr
+    when Float
+      (arr * 10**precision).round * 10**-precision
+    when Array
+      arr.map{|i| format i, precision}
+    else
+      arr
+    end
+  end
+
+  def gun_vector
+    Vector[Math.cos(gun_heading.deg2rad), -Math.sin(gun_heading.deg2rad)]
+  end
+
+  def heading_for(position)
+    distance = position - Vector[x,y]
+    heading = (Math.atan2(-distance[1], distance[0])).rad2deg
+    heading += 360 if heading < 0
+    heading
+  end
+
+  def navigate events
+    if events['got_hit'].empty?
+      @serial_hit_counter -= 0.05 if @serial_hit_counter > 0
+      accelerate(@racc_dir) if velocity.abs < 7.9
+    else
+      @serial_hit_counter += @prev_health - events['got_hit'].last.last
+      @serial_hit_counter = [@serial_hit_counter, @serial_hit_limit + 0.04].max
+      if @serial_hit_counter > @serial_hit_limit
+        acc = velocity > 0 ? 1 : -1
+        accelerate(acc) if velocity.abs < 7.9
+      end
+    end
+    if @serial_hit_counter > @serial_hit_limit and not events['got_hit'].empty? and @wanted_turn <= 1
+      @wanted_turn = @rturn_dir * 30
+      @rturn_dir *= -1 if rand < 0.05
+    elsif approaching_wall? and @wanted_turn <= 1
+      @wanted_turn = 60 * @rturn_dir
+      @rturn_dir *= -1 if rand < 0.5
+    elsif rand < 0.15
+      @wanted_turn += rand * 10 * @rturn_dir
+    elsif rand < 0.01
+      @rturn_dir *= -1
+    elsif rand < 0.01
+      @racc_dir *= -1
+    end
+  end
+
+  def increase_radar_scan
+    @radar_scan *= 1.5
+    @radar_scan = [@radar_scan, @max_radar_scan].min
+  end
+
+  def decrease_radar_scan
+    @radar_scan *= 0.5
+    @radar_scan = [@radar_scan, @min_radar_scan].max
+  end
+
+  def heading_distance h1, h2
+    limit h2 - h1, 180
+  end
+
+  def limit value, m
+    value -= 360 if value > 180
+    value += 360 if value < -180
+    value = -m if value < -m
+    value = m if value > m
+    return value
+  end
+
+  def gun_radar_distance
+    heading_distance gun_heading, radar_heading
+  end
+
+  def turn_hull
+    turn_amt = [-10.0, [@wanted_turn, 10.0].min].max
+    #puts "Turning hull by: #{turn_amt}" if turn_amt.abs > 1
+    turn turn_amt
+    @wanted_turn -= turn_amt
+    @wanted_gun_turn -= turn_amt
+    @wanted_radar_turn -= turn_amt
+  end
+
+  def turn_turret
+    turn_amt = [-30.0, [@wanted_gun_turn, 30.0].min].max
+    #puts "Turning gun by: #{turn_amt}" if turn_amt.abs > 1
+    turn_gun turn_amt
+    @wanted_gun_turn -= turn_amt
+    @wanted_radar_turn -= turn_amt
+  end
+
+  def turn_radar_dish
+    turn_amt = [-60.0, [@wanted_radar_turn, 60.0].min].max
+    #puts "Turning radar by: #{turn_amt}" if turn_amt.abs > 1
+    turn_radar turn_amt
+    @wanted_radar_turn -= turn_amt
+  end
+
+  def approaching_wall?
+    if not ( (velocity > 0) ^ heading.between?(0.0, 180.0) )
+      y < 100
+    else
+      y > battlefield_height - 100
+    end or if not ( (velocity > 0) ^ heading.between?(90.0, 270.0) )
+      x < 100
+    else
+      x > battlefield_width - 100
+    end
+  end
+
+end