UG_RRobots 1.2

data/robots/EdgeBot.rb

@@ -0,0 +1,203 @@
+# EdgeBot.rb
+require 'robot'
+
+class EdgeBot
+include Robot
+
+@@east = 0
+@@north = 90
+@@west = 180
+@@south = 270
+@@none = -1
+
+@@direction = {
+:east => {
+:angle => @@east,
+:inward_angle => @@west,
+:next_edge => [:north, :south]
+},
+:north => {
+:angle => @@north,
+:inward_angle => @@south,
+:next_edge => [:west, :east]
+},
+:west => {
+:angle => @@west,
+:inward_angle => @@east,
+:next_edge => [:south, :north]
+},
+:south => {
+:angle => @@south,
+:inward_angle => @@north,
+:next_edge => [:east, :west]
+}
+}
+
+@@max_robot_turn = 10
+@@max_gun_turn = 30
+@@max_radar_turn = 60
+@@max_speed = 8
+
+@@chicken_energy = 10
+
+def tick( events )
+if time == 0
+@direction = 0
+@target_angle = Hash.new
+@next_edge = nearest_edge
+@target_angle[:robot] = @@direction[@next_edge][:angle]
+@target_angle[:gun] = @@direction[@next_edge][:angle]
+@target_angle[:radar] = @@direction[@next_edge][:angle]
+@mode = :seek_edge
+@prev_radar_heading = radar_heading
+@fire_power = 3
+end
+
+rotate!
+fire( @fire_power )
+
+case @mode
+when :seek_edge
+# puts "seek_edge"
+@fire_power = 0.1
+if @turn_complete
+@mode = :move_to_edge
+end
+when :move_to_edge
+# puts "move_to_edge"
+fire( 3 ) unless events['robot_scanned'].empty?
+unless at_edge? @next_edge
+accelerate( 1 )
+else
+@current_edge = @next_edge
+@next_edge = @@direction[@current_edge][:next_edge][@direction]
+@target_angle[:robot] = @@direction[@next_edge][:angle]
+@target_angle[:gun] = @@direction[@current_edge][:inward_angle]
+@target_angle[:radar] = @@direction[@next_edge][:angle]
+@mode = :edge_align
+end
+when :edge_align
+# puts "edge_align"
+@fire_power = 0.1
+if speed != 0
+stop
+end
+if @turn_complete && @prev_radar_heading == radar_heading
+# Pause for a still radar shot before progressing
+@mode = :fire
+end
+if edge_occupied?( @@direction[@next_edge][:angle], events )
+@mode = :clear_edge_align
+@target_angle[:gun] = @@direction[@next_edge][:angle]
+@target_angle[:radar] = @@direction[@next_edge][:angle]
+end
+when :fire
+# puts "fire"
+@fire_power = 0.1
+if velocity < @@max_speed
+accelerate( 1 )
+end
+if at_edge?( @next_edge )
+@current_edge = @next_edge
+@next_edge = @@direction[@current_edge][:next_edge][@direction]
+@target_angle[:robot] = @@direction[@next_edge][:angle]
+@target_angle[:gun] = @@direction[@current_edge][:inward_angle]
+@target_angle[:radar] = @@direction[@next_edge][:angle]
+@mode = :edge_align
+elsif edge_occupied?( @@direction[@next_edge][:angle], events )
+@mode = :clear_edge_align
+@target_angle[:gun] = @@direction[@next_edge][:angle]
+@target_angle[:radar] = @@direction[@next_edge][:angle]
+end
+when :clear_edge_align
+# puts "clear_edge_align"
+@fire_power = 0.1
+if speed != 0
+stop
+end
+if @turn_complete
+@mode = :clear_edge
+end
+when :clear_edge
+@fire_power = 0.1
+if not edge_occupied?( @@direction[@next_edge][:angle], events )
+@target_angle[:gun] = @@direction[@current_edge][:inward_angle]
+@target_angle[:radar] = @@direction[@next_edge][:angle]
+@mode = :edge_align
+elsif energy < @@chicken_energy
+reverse_course!
+end
+end
+
+@prev_radar_heading = radar_heading
+end
+
+def rotate!
+@turn_complete = true
+if @target_angle[:robot] != @@none && heading != @target_angle[:robot]
+turn( angle_to( @target_angle[:robot], heading, @@max_robot_turn ) )
+@turn_complete = false
+elsif @target_angle[:gun] != @@none && gun_heading != @target_angle[:gun]
+turn_gun( angle_to( @target_angle[:gun], gun_heading, @@max_gun_turn ) )
+@turn_complete = false
+elsif @target_angle[:radar] != @@none && radar_heading != @target_angle[:radar]
+turn_radar( angle_to( @target_angle[:radar], radar_heading, @@max_radar_turn ) )
+@turn_complete = false
+end
+end
+
+def angle_to( target_heading, current_heading, max_turn )
+normalised_heading = current_heading - target_heading
+dir = (normalised_heading < 180) ? -1 : 1
+if normalised_heading < max_turn
+return dir * normalised_heading
+else
+return dir * max_turn
+end
+end
+
+def at_edge?( edge )
+case edge
+when :east
+return x >= (battlefield_width - size)
+when :north
+return y <= size
+when :west
+return x <= size
+when :south 
+return y >= (battlefield_height - size)
+end
+end
+
+def edge_occupied?( angle, events )
+return (@prev_radar_heading == angle && 
+radar_heading == angle &&
+!events['robot_scanned'].empty?)
+end
+
+def nearest_edge
+min = [:west, x]
+if y < min[1]
+min = [:north, y]
+end
+if battlefield_width - x < min[1]
+min = [:east, battlefield_width - x]
+end
+if battlefield_height - y < min[1]
+min = [:south, battlefield_height - y]
+end
+return min[0]
+end
+
+def reverse_course!
+@direction = (@direction + 1) % 2
+@next_edge = @@direction[@current_edge][:next_edge][@direction]
+@target_angle[:robot] = @@direction[@next_edge][:angle]
+@target_angle[:gun] = @@direction[@current_edge][:inward_angle]
+@target_angle[:radar] = @@direction[@next_edge][:angle]
+@mode = :edge_align
+end
+
+end
+ 
+

data/robots/HuntingDuck.rb

@@ -0,0 +1,74 @@
+require 'robot'
+
+class HuntingDuck
+include Robot
+def initialize *bf
+    if bf.size != 0
+      super(bf[0])
+      @tourney = false
+    else
+      super
+      @tourney = true
+    end
+ @time_since=10
+@direction=1
+@rob_distance=200
+end
+def rel_direction(from,to)
+rel = to -from
+if rel > 180 
+rel = -360 + rel
+end
+if rel < -180
+rel = 360+rel
+end 
+return rel
+end 
+def rel_gun_heading
+rel_direction(heading, gun_heading)
+end
+def tick events
+accelerate 1
+@rob_distance=events['robot_scanned'][0][0] unless events['robot_scanned'].empty?
+if @rob_distance > 800
+#make small turret adjustments when distance to enemy is great
+turret_turn=3
+else
+turret_turn=6
+end
+#turn clockwise or counter clockwise?
+@direction = -@direction if Kernel.rand < 0.02
+if !events['got_hit'].empty?
+#if we got hit we'd better shoot back and try to turn away
+fire 2
+turn -10*@direction
+end
+if !events['robot_scanned'].empty?
+fire 3
+@time_since=0
+else
+if @time_since < 15
+#spotted the enemy, moving closer 
+#while moving the turret to spot him again
+if Kernel.rand < 0.5 && rel_gun_heading < 30
+turn_gun turret_turn
+elsif rel_gun_heading > -30
+turn_gun -turret_turn
+else
+turn_gun turret_turn
+end
+fire 0.5
+elsif @time_since < 100
+#try to spot the enemy
+turn 10*@direction
+else
+#if we got stuck this should get us out
+turn 5
+end
+end
+@time_since += 1
+end
+end
+
+ 
+

data/robots/HyperactiveDuck.rb

@@ -0,0 +1,15 @@
+require 'robot'
+
+class HyperactiveDuck
+   include Robot
+
+  def tick events
+    turn_radar 1 if time == 0
+    accelerate 1
+    turn 2
+	if !events['robot_scanned'].empty? && gun_heat <= 0
+		fire 1
+		turn_gun -30		
+	end
+  end
+end

data/robots/Killer.rb

@@ -0,0 +1,58 @@
+require 'robot'
+
+class Killer
+  include Robot
+  
+  def min_max 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
+    @dist = 1000 if @dist.nil?
+    @target_heading = 0 if @target_heading.nil?
+    @predicted_heading = 0 if @predicted_heading.nil?
+    @radar_range = 60 if @radar_range.nil?
+    @direction = 1 if @direction.nil?
+    
+    if !events['robot_scanned'].empty?
+      @dist = events['robot_scanned'].first.first
+      @target_heading = radar_heading - @radar_range * 0.5
+      @predicted_heading = @target_heading + 16.0 * (rand(3)-1)
+      if (@dist * @radar_range.abs <= 500)
+        sx = x + Math::cos(@target_heading / 180 * Math::PI) * @dist
+        sy = y - Math::sin(@target_heading / 180 * Math::PI) * @dist
+        if @last_scan && (time - @last_scan[2]) == 1
+          px = sx + (sx - @last_scan[0]) * (@dist - 90) / 30
+          py = sy + (sy - @last_scan[1]) * (@dist - 90) / 30
+          @predicted_heading = Math.atan2(y - py, px - x) / Math::PI * 180 % 360	  
+        end
+        @last_scan = [sx, sy, time]
+      end
+      @radar_range = (@dist * @radar_range.abs > 250) ? -@radar_range * 0.5 : -@radar_range
+    else
+      @radar_range *= -2 if (@radar_range.abs < 60)
+    end 
+  
+    fire 3
+    
+    if ((x < 100) || (x > 1500) || (y < 100) || (y > 1500)) && (@escape.nil? || @escape.zero?)
+      @escape = 30
+      @direction *= -1
+    end
+      
+    @escape -= 1 if @escape && (@escape > 0)
+    accelerate(@direction)
+    
+    turn_body = min_max(@target_heading - heading + 90, 10)
+    gun = min_max(@predicted_heading - gun_heading - turn_body, 30)
+    radar = min_max(@radar_range - gun - turn_body, 60)
+    
+    turn(turn_body)
+    turn_gun(gun)
+    turn_radar(radar)
+  end
+end

data/robots/Kite.rb

@@ -0,0 +1,193 @@
+# Uses linear targetting and
+# moves in a way that dodges linear targetting.
+# Not very good for melee.
+#
+require 'robot'
+require 'matrix'
+
+class Numeric
+  def deg2rad
+    self * 0.0174532925199433
+  end
+  def rad2deg
+    self * 57.2957795130823
+  end
+  def sign
+    self / abs
+  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 Kite
+include Robot
+
+  def initialize *args, &block
+    super
+    @rt = @radar_scan = 15
+    @min_radar_scan = 1.5
+    @max_radar_scan = 60.0
+    @lock = false
+    @firing_threshold = 20.0
+    @wanted_turn = @wanted_gun_turn = @wanted_radar_turn = 0
+    @rturn_dir = 1
+    @racc_dir = 1
+    @target_positions = []
+    @sd_limit = 30
+  end
+
+  def tick events
+    @prev_health = energy if time == 0
+    if events['robot_scanned'].empty?
+      @radar_scan = [@radar_scan * 1.5, @max_radar_scan].min
+    else
+      @radar_scan = [@radar_scan * 0.5, @min_radar_scan].max
+    end
+    @rt = (time/2 % 2 < 1 ? -@radar_scan/2.0 : @radar_scan/2.0) if @radar_scan.abs < @max_radar_scan - 0.1
+    @wanted_radar_turn += @rt
+    firing_solution events
+    @hit = unless events['got_hit'].empty?
+      @racc_dir = @racc_dir / @racc_dir.abs 
+      20
+    else
+      (@hit||0) - 1
+    end
+    if @hit < 0
+      @racc_dir = (@min_distance and @min_distance < 450) ? @racc_dir.sign : Math.sin(time*0.1+rand*0.2)
+    end
+    accelerate(@racc_dir)
+    if approaching_wall?
+      @wanted_turn = 60 * @rturn_dir
+    elsif @target_heading and @wanted_turn <= 1
+      @wanted_turn = heading_distance(((@min_distance and @min_distance < 450) ? (90-@rturn_dir.sign*30)*-@racc_dir.sign : 0)+heading, 90+@target_heading)
+    elsif rand < 0.3
+      @wanted_turn += rand * 10 * @racc_dir.sign * @rturn_dir
+    elsif rand < 0.01
+      @rturn_dir *= -1
+    elsif rand < 0.01
+      @racc_dir *= -1
+    end
+    turn_hull
+    turn_turret
+    turn_radar_dish
+    @prev_health = energy
+  end
+
+  def firing_solution events
+    unless events['robot_scanned'].empty?
+      last = @target_positions.last || Vector[0,0]
+      position = events['robot_scanned'].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]
+        Vector[tx,ty]
+      }.min{|a,b| (a - last).r <=> (b - last).r }
+      @target_positions.push position
+      @min_distance = events['robot_scanned'].flatten.min
+    end
+    @target_positions.shift if @target_positions.size > 10
+    @min_distance = nil if @target_positions.empty?
+    @target_heading = target_heading
+    gtd = heading_distance(gun_heading, @target_heading) if @target_heading
+    @firepower = [3*25 / (@vsd||1500)].max / 2.0
+    fire @firepower if @on_target
+    if gtd and gtd.abs < @firing_threshold
+      @wanted_gun_turn = gtd
+      @on_target = true
+    else
+      @wanted_gun_turn = gtd || (gun_radar_distance/3.0)
+      @on_target = false
+    end
+  end
+  
+  def average arr
+    arr.inject{|s,i| s+i} * (1.0/arr.size)
+  end
+
+  def target_heading
+    return nil if @target_positions.size < 10
+    return radar_heading if @min_distance and @min_distance < 200
+    lps = (0...5).map{|i| @target_positions[i*2,2] }.map{|pta| average(pta) }
+    p4 = lps.last
+    vs = lps[0..-2].zip(lps[1..-1]).map{|a,b| (b-a) * 0.5 }
+    @vsd = Math.sqrt(vs.map{|v| v[0]}.sd**2 + vs.map{|v| v[1]}.sd**2)
+    return nil if @vsd > @sd_limit
+    v = average(vs)
+    return heading_for(average(lps)) if v.r < 4.0
+    p4 = p4 + (v*0.5)
+    distance = p4 - Vector[x,y]
+    shot_speed = (30/8.0)*v.r
+    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**2
+    t = 2*a / (-b + Math.sqrt(b**2-4*a*c))
+    ep = p4 + v*t
+    estimated_position = Vector[
+      [size, [battlefield_width-size, ep[0]].min].max, 
+      [size, [battlefield_height-size, ep[1]].min].max]
+    heading_for(estimated_position) + (rand-0.5)*@vsd*0.2
+  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 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
+    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
+    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
+    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