Pistos-weewar-ai 2008.06.10.0

data/READTHAT

@@ -0,0 +1 @@
+Don't read ME; read THAT!

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+
+$:.unshift File.join( File.dirname(__FILE__), "lib" )
+
+root = File.expand_path( File.dirname(__FILE__) )
+
+# ------------------
+
+#task :default => ['spec']
+#task :test => ['spec']
+
+desc "generate rdoc"
+Rake::RDocTask.new do |rdoc|
+  files = [
+    'lib/**/*.rb',
+    #'examples/*.rb',
+    'THAT',
+    'READTHAT'
+    #'spec/**/*.rb',
+  ]
+  rdoc.rdoc_files.add( files )
+  rdoc.main = "WeewarAI::AI" # page to start on
+  rdoc.title = "Weewar AI Ruby library"
+#  rdoc.template = "/misc/pistos/unpack/allison-2.3/allison.rb"
+  rdoc.template = "jamis"
+  rdoc.rdoc_dir = '/var/www/localhost/htdocs/weewar/ai-doc' # rdoc output folder
+  rdoc.options << '--line-numbers' << '--inline-source'
+end
+
+#desc 'Run coverage examiner (rcov)'
+#task 'rcov' do
+#   exec( "rcov -o /var/www/localhost/htdocs/m4dbi/rcov spec/*.rb" )
+#end
+
+#desc 'Run all specs'
+#task 'spec' do
+#  exec "bacon #{root}/spec/*.rb"
+#end
+
+#desc 'Build nightly gem'
+#task 'nightly' do
+#  output = `gem build #{root}/gemspecs/m4dbi-nightly.gemspec`
+#  version = Time.now.strftime( "%Y.%m.%d" )
+#  `mv m4dbi-#{version}.gem m4dbi-nightly.gem`
+#end
+
+desc 'Make release'
+task 'release' do
+  output = `gem build weewar-ai.gemspec`
+end
+
+#desc 'Build examples from specs'
+#task 'examples' do
+#  Dir[ 'spec/*.rb' ].each do |specfile|
+#    next if specfile =~ /helper\.rb/
+#    base = File.basename( specfile, ".rb" )
+#    `ruby -I /misc/svn/specs2examples/lib /misc/svn/specs2examples/bin/specs2examples #{specfile} > /var/www/localhost/htdocs/m4dbi/examples/#{base}.html`
+#  end
+#end

data/THAT

@@ -0,0 +1,23 @@
+== Dependencies
+
+- XMLSimple
+- Mechanize
+- Hpricot
+
+The dependencies should be pulled along with the main gem installation.
+
+== Installation
+
+  gem install weewar-ai --source http://purepistos.net
+
+== Usage
+
+See examples/ dir.  See rdoc at http://weewar.purepistos.net/ai-doc/ .
+
+== Source Code
+
+  git clone git://github.com/Pistos/weewar-ai.git
+  cd /usr/lib/ruby/site_ruby/1.8
+  ln -s /path/to/cloned/weewar-ai/lib/weewar-ai.rb
+  ln -s /path/to/cloned/weewar-ai/lib/weewar-ai
+  

data/examples/basic.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require 'weewar-ai'
+#$debug = true
+
+# A simple, working example of using the WeewarAI library.
+# This bot's strategy is simply to build infantry and move them onto any
+# bases it does not own.  It will attack any enemies it meets along the way.
+
+class AIBasic < WeewarAI::AI
+  
+  def initialize
+    super(
+      :server => 'test.weewar.com',
+      :username => 'aiBasic',  # change this to your bot's username
+      :api_key => 'GMmTBxE2ztNbdABAW5vgVZVhH'  # change this to your bot's API key
+    )
+  end
+  
+  def run_once
+    one_accepted = accept_all_invitations
+    if one_accepted
+      puts "Accepted some invitations."
+      refresh
+    end
+    
+    @needy_games.each do |g|
+      take_turn g
+    end
+  end
+  
+  def take_turn( game )
+    puts
+    puts "*" * 80
+    puts "Taking turn for game #{game.id}"
+    i = me = my = game.my_faction
+
+    # Find a place to go, things to shoot
+    destination = game.enemy_bases.first
+    enemies = game.enemy_units
+    
+    # Move units
+    my.units.find_all { |u| not u.finished? }.each do |unit|
+      unit.move_to(
+        destination,
+        :also_attack => enemies
+      )
+    end
+    
+    # Build
+    game.my_bases.each do |base|
+      next if base.occupied?
+      
+      if i.can_afford?( :linf )
+        base.build :linf
+      end
+    end
+    
+    puts "Ending turn for game #{game.id}"
+    game.finish_turn
+  end
+  
+end
+
+begin
+  bot = AIBasic.new
+  bot.run_once
+rescue Exception => e
+  $stderr.puts "#{e.class}: #{e.message}"
+  $stderr.puts e.backtrace.join( "\n\t" )
+end

data/lib/weewar-ai.rb

@@ -0,0 +1,14 @@
+require 'xmlsimple'
+
+_DIR = File.expand_path( File.dirname( __FILE__ ) )
+
+require "#{_DIR}/weewar-ai/__dir__"
+require "#{__DIR__}/weewar-ai/traits"
+require "#{__DIR__}/weewar-ai/player"
+require "#{__DIR__}/weewar-ai/faction"
+require "#{__DIR__}/weewar-ai/hex"
+require "#{__DIR__}/weewar-ai/unit"
+require "#{__DIR__}/weewar-ai/map"
+require "#{__DIR__}/weewar-ai/game"
+require "#{__DIR__}/weewar-ai/api"
+require "#{__DIR__}/weewar-ai/ai"

data/lib/weewar-ai/__dir__.rb

@@ -0,0 +1,23 @@
+# From Ramaze ( http://ramaze.net )
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+
+# Extensions for Kernel
+
+module Kernel
+  unless defined?__DIR__
+  
+    # This is similar to +__FILE__+ and +__LINE__+, and returns a String
+    # representing the directory of the current file is.
+    # Unlike +__FILE__+ the path returned is absolute.
+    #
+    # This method is convenience for the
+    #  File.expand_path(File.dirname(__FILE__))
+    # idiom.
+    #
+    
+    def __DIR__()
+      filename = caller[0][/^(.*):/, 1]
+      File.expand_path(File.dirname(filename))
+    end
+  end
+end

data/lib/weewar-ai/ai.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+# All parts of the library reside in the WeewarAI module.
+module WeewarAI
+  
+  # Begin creating your bot by subclassing the WeewarAI::AI class.
+  #
+  #    class MyBot < WeewarAI::AI
+  #    end
+  #
+  # See examples/basic.rb for a simple working example.
+  class AI
+    # In your bot's initialize method, call the AI superclass's
+    # initialize method with these parameters (values are examples):
+    #
+    #   super(
+    #     :server => 'test.weewar.com',
+    #     :username => 'aiMyBot',
+    #     :api_key => 'r0goujPhKJEM6udL3RNfBtcS9',
+    #   )
+    #
+    # Retrieve your API key from http://test.weewar.com/apiToken .
+    #
+    # Once constructed, your AI instance will have the following instance
+    # variables available:
+    #
+    # @games       : An Array of the Game s your AI is in.
+    #
+    # @needy_games : The subset of Game s in which it is your AI's turn.
+    #
+    # @invitations : The ids of Game s to which your AI is invited.
+    def initialize( params )
+      @username = params[ :username ]
+      WeewarAI::API.init( params )
+      refresh
+    end
+
+    # Retrieves your AI's headquarters data from the game server,
+    # and updates the instance variables @games, @needy_games and
+    # @invitations.
+    #   bot.refresh
+    def refresh
+      xml = XmlSimple.xml_in(
+        WeewarAI::API.get( "/headquarters" ),
+        { 'ForceArray' => [ 'game' ], }
+      )
+      gxml = xml[ 'game' ]
+      @invitations = gxml.find_all { |g|
+        g[ 'link' ] =~ /join/
+      }.map { |g|
+        g[ 'id' ].to_i
+      }
+      gxml = gxml.reject { |g|
+        @invitations.include? g[ 'id' ].to_i
+      }
+      @games = gxml.map { |g|
+        WeewarAI::Game.new( g[ 'id' ] )
+      }
+      @needy_games = @games.find_all { |g|
+        g.current_player and g.current_player.name == @username
+      }
+    end
+    
+    # Accepts the invitation to join the game identified by the game_id.
+    #   bot.accept_invitation 165
+    def accept_invitation( game_id )
+      response = WeewarAI::API.accept_invitation( game_id )
+      %r{<ok/>} === response
+    end
+    
+    # Accepts all game invitations.
+    #   bot.accept_all_invitations
+    def accept_all_invitations
+      one_accepted = false
+      @invitations.each do |invitation|
+        one_accepted ||= accept_invitation( invitation )
+      end
+      one_accepted
+    end
+  end
+end

data/lib/weewar-ai/api.rb

@@ -0,0 +1,100 @@
+require 'mechanize'
+
+module WeewarAI
+  GOD_LOVES_YOU = true
+  VERSION = '2008.06.09'
+  
+  # The API class contains some lower-level methods. You should not normally
+  # need to use them yourself.  Instead, use the methods of your AI instance.
+  class API
+    # Initializes the connection to the weewar.com API.  You do not need to
+    # call this yourself; it is called for you when you subclass AI.
+    def self.init( params )
+      [ :server, :username, :api_key ].each do |required_param|
+        if params[ required_param ].nil? or params[ required_param ].strip.empty?
+          raise "Missing #{required_param}."
+        end
+      end
+      
+      trait[ :agent ] = agent = WWW::Mechanize.new
+      trait[ :username ], trait[ :api_key ] = params[ :username ], params[ :api_key ]
+      agent.basic_auth( params[ :username ], params[ :api_key ] )
+      trait[ :server ] = params[ :server ]
+      
+      Hex.initialize_specs
+    end
+    
+    def self.username
+      trait[ :username ]
+    end
+    def self.agent
+      trait[ :agent ]
+    end
+    def self.server
+      trait[ :server ]
+    end
+    
+    def self.get( path )
+      result = nil
+      retries = 0
+      while GOD_LOVES_YOU
+        url = "http://#{server}/api1/#{path}"
+        begin
+          result = agent.get( url ).body
+          break
+        rescue EOFError, Errno::EPIPE => e
+          if retries < 10
+            $stderr.puts "Communications error fetching '#{url}'.  Retrying (#{retries})..."
+            sleep retries + 3
+            retries += 1
+          else
+            break
+          end
+        end
+      end
+      if $debug
+        $stderr.puts "XML RECEIVE: #{result}"
+      end
+      result
+    end
+    
+    def self.send( xml )
+      url = URI.parse( "http://#{server}/api1/eliza" )
+      req = Net::HTTP::Post.new( url.path )
+      req.basic_auth( trait[ :username ], trait[ :api_key ] )
+      req[ 'Content-Type' ] = 'application/xml'
+      result = Net::HTTP.new( url.host, url.port ).start { |http|
+        if $debug
+          $stderr.puts "XML SEND: #{xml}"
+        end
+        http.request( req, xml )
+      }.body
+      if $debug
+        $stderr.puts "XML RECEIVE: #{result}"
+      end
+      result
+    end
+    
+    # Accepts an invitation to a game.
+    def self.accept_invitation( game_id )
+      send "<weewar game='#{game_id}'><acceptInvitation/></weewar>"
+    end
+    
+    # Declines an invitation to a game.
+    def self.decline_invitation( game_id )
+      send "<weewar game='#{game_id}'><declineInvitation/></weewar>"
+    end
+    
+    # Removes a game from your AI's headquarters.
+    def self.remove_game( game_id )
+      send "<weewar game='#{game_id}'><removeGame/></weewar>"
+    end
+    
+    class << self
+      alias acceptInvitation accept_invitation
+      alias declineInvitation decline_invitation
+      alias removeGame remove_game
+    end
+    
+  end
+end

data/lib/weewar-ai/faction.rb

@@ -0,0 +1,57 @@
+module WeewarAI
+  
+  # Instances of the Faction class correspond to factions in a Game.
+  # They provide some utility methods about factions, such as whether
+  # or not a faction is currently playing in a Game, or whether it can
+  # afford to buy a unit type.
+  class Faction
+    attr_reader :credits, :player_id, :player_name, :state
+    
+    # You should not need to instantiate any Faction s on your own;
+    # they are created for you by Game instances.
+    def initialize( game, xml, ordinal )
+      @game, @ordinal = game, ordinal
+      @credits = xml[ 'credits' ].to_i
+      @current = ( xml[ 'current' ] == 'true' )
+      @player_id = xml[ 'playerId' ].to_i
+      @player_name = xml[ 'playerName' ]
+      @state = xml[ 'state' ]
+    rescue Exception => e
+      $stderr.puts "Input XML: " + xml.inspect
+      raise e
+    end
+    alias playerId player_id
+    alias playerName player_name
+    
+    # Whether or not this Faction is the one whose turn it is in the Game.
+    #   i = me = my = game.my_faction
+    #   is_my_turn = i.current?
+    def current?
+      @current
+    end
+    
+    def playing?
+      @state == 'playing'
+    end
+    
+    # True iff the faction has enough credits to purchase a unit of the given type.
+    #   i = me = my = game.my_faction
+    #   if i.can_afford? :hart
+    #     my_base.build :hart
+    #   end
+    def can_afford?( type )
+      @credits >= WeewarAI::Unit::UNIT_COSTS[ type ]
+    end
+    
+    # An Array of the Unit s in the Game belonging to this Faction.
+    #   i = me = my = game.my_faction
+    #   my_units = my.units
+    def units
+      @game.units.find_all { |u| u.faction == self }
+    end
+   
+    def to_s
+      @player_name
+    end
+  end
+end

data/lib/weewar-ai/game.rb

@@ -0,0 +1,173 @@
+require 'net/http'
+require 'pistos'
+
+module WeewarAI
+  
+  # The Game class is your interface to a game on the weewar server.
+  # Game instances are used to do such things as finish turns, surrender,
+  # and abandon.  Also, you access game maps and units through a Game
+  # instance.
+  class Game
+    attr_reader :id, :name, :round, :state, :pending_invites, :pace, :type,
+      :url, :map, :map_url, :credits_per_base, :initial_credits, :playing_since,
+      :players, :units
+    attr_accessor :last_attacked
+    
+    # Instantiate a new Game instance corresponding to the weewar game
+    # with the given id number.
+    #   game = WeewarAI::Game.new( 132 )
+    def initialize( id )
+      @id = id.to_i
+      refresh
+    end
+    alias pendingInvites pending_invites
+    alias mapUrl map_url
+    alias creditsPerBase credits_per_base
+    alias initialCredits initial_credits
+    alias playingSince playing_since
+    
+    # Hits the weewar server for all the game state data as it sees it.
+    # All internal variables are updated to match.
+    #   my_game.refresh
+    def refresh
+      xml = XmlSimple.xml_in(
+        WeewarAI::API.get( "/gamestate/#{id}" ),
+        { 'ForceArray' => [ 'faction', 'player', 'terrain', 'unit' ], }
+      )
+      #$stderr.puts xml.nice_inspect
+      @name = xml[ 'name' ]
+      @round = xml[ 'round' ].to_i
+      @state = xml[ 'state' ]
+      @pending_invites = ( xml[ 'pendingInvites' ] == 'true' )
+      @pace = xml[ 'pace' ].to_i
+      @type = xml[ 'type' ]
+      @url = xml[ 'url' ]
+      @players = xml[ 'players' ][ 'player' ].map { |p| WeewarAI::Player.new( p ) }
+      @map = WeewarAI::Map.new( self, xml[ 'map' ].to_i )
+      @map_url = xml[ 'mapUrl' ]
+      @credits_per_base = xml[ 'creditsPerBase' ]
+      @initial_credits = xml[ 'initialCredits' ]
+      @playing_since = Time.parse( xml[ 'playingSince' ] )
+      
+      @units = Array.new
+      @factions = Array.new
+      xml[ 'factions' ][ 'faction' ].each_with_index do |faction_xml,ordinal|
+        faction = Faction.new( self, faction_xml, ordinal )
+        @factions << faction
+        
+        faction_xml[ 'unit' ].each do |u|
+          hex = @map[ u[ 'x' ], u[ 'y' ] ]
+          unit = Unit.new(
+            self,
+            hex,
+            faction,
+            u[ 'type' ],
+            u[ 'quantity' ].to_i,
+            u[ 'finished' ] == 'true',
+            u[ 'capturing' ] == 'true'
+          )
+          @units << unit
+          hex.unit = unit
+        end
+        
+        faction_xml[ 'terrain' ].each do |terrain|
+          hex = @map[ terrain[ 'x' ], terrain[ 'y' ] ]
+          if hex.type == :base
+            hex.faction = faction
+          end
+        end
+      end
+    end
+    
+    # Sends some command XML for this game to the server.  You should
+    # generally never need to call this method directly; it is used
+    # internally by the Game class.
+    def send( command_xml )
+      WeewarAI::API.send "<weewar game='#{@id}'>#{command_xml}</weewar>"
+    end
+    
+    #-- -------------------------
+    # API Commands
+    #++
+    
+    # End turn in this game.
+    #   game.finish_turn
+    def finish_turn
+      send "<finishTurn/>"
+    end
+    alias finishTurn finish_turn
+    
+    # Surrender in this game.
+    #  game.surrender
+    def surrender
+      send "<surrender/>"
+    end
+    
+    # Abandon this game.
+    #  game.abandon
+    def abandon
+      send "<abandon/>"
+    end
+    
+    #-- -------------------------
+    # Game state
+    #++
+    
+    # The Player whose turn it is.
+    #   turn_taker = game.current_player
+    def current_player
+      @players.find { |p| p.current? }
+    end
+    
+    #-- --------------------------------------------------
+    # Utilities
+    #++
+    
+    # The Faction of the given player.
+    #   pistos_faction = game.faction_for_player 'Pistos'
+    def faction_for_player( player_name )
+      @factions.find { |f| f.player_name == player_name }
+    end
+    
+    # Your AI's Faction in this game.
+    #   me = my = i = game.my_faction
+    #   puts "My name is #{my.player_name}."
+    #   if i.can_afford? :htank
+    #     my_base.build :htank
+    #   end
+    def my_faction
+      faction_for_player WeewarAI::API.username
+    end
+    
+    # An Array of the Units not belonging to your AI.
+    #   bad_guys = game.enemy_units
+    def enemy_units
+      @units.find_all { |u| u.faction != my_faction }
+    end
+    
+    # An Array of the base Hexes for this game.
+    #   bases = game.bases
+    def bases
+      @map.bases
+    end
+    
+    # An Array of the base Hexes owned by the given faction.
+    #   their_bases = game.bases enemy_faction
+    def bases_of( faction )
+      @map.bases.find_all { |b| b.faction == faction }
+    end
+    
+    # Your AI's bases in this game.
+    #   good_bases = game.my_bases
+    def my_bases
+      bases_of my_faction
+    end
+    
+    # An Array of bases not owned by your AI (including neutral bases).
+    #   capturable_bases = game.enemy_bases
+    def enemy_bases
+      @map.bases.find_all { |b| b.faction != my_faction }
+    end
+        
+  end
+end