colstrom-rtanque 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5bb81d35a1207166bc9b7916b483204c4de420b6
+  data.tar.gz: d432f6a4c1422a07238ac0bb28181afb2e8f9a50
+SHA512:
+  metadata.gz: 7af7f69becd7608f1f9c6f50e38cf9d4679f54d3bd1ac9ce031405b7886d677cb7f9aed246e45e325a26ebded823845ffc1cde7fd49168b29804deccf94832d4
+  data.tar.gz: 390ed015f716aa4fd65e340f522d02b909117e9dfeee12bfecac0865298f879ee843eaaf7dc958a22b291c0960a8a49fde68602642eef8c5f2acc6d48a6b6788

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+twitter_images/
+bots/
+example.rb
+examples/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+RTanque

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+gemfile: Gemfile.ci
+script: bundle exec rspec
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+branches:
+  only:
+    - master

data/.yardopts

@@ -0,0 +1,4 @@
+--markup markdown
+--no-private
+--files sample_bots/*
+-

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rtanque.gemspec
+gemspec

data/Gemfile.ci

@@ -0,0 +1,6 @@
+# Gemfile for Travis. Doesn't require gosu which doesn't compile in Travis
+source 'https://rubygems.org'
+
+gem 'rspec'
+gem 'rspec-mocks'
+gem 'configuration'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Adam Williams
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,168 @@
+# RTanque [![Build Status](https://travis-ci.org/awilliams/RTanque.png?branch=dev)](https://travis-ci.org/awilliams/RTanque) [![CodeClimate](https://codeclimate.com/github/awilliams/RTanque.png)](https://codeclimate.com/github/awilliams/RTanque)
+
+**What is this?**
+RTanque is a game for ( *Ruby* ) programmers. Players program the brain of a tank and then send their tank+brain into battle with other tanks. All tanks are otherwise equal.
+
+[Getting started guide](http://awilliams.github.io/articles/rtanque-getting-started/)
+
+Rules of the game are simple: Last bot standing wins. Gameplay is also pretty simple. Each tank has a **base**, **turret** and **radar**, each of which rotate independently. The base moves the tank, the turret has a gun mounted to it which can fire at other tanks, and the radar detects other tanks in its field of vision.
+
+Have fun competing against friends' tanks or the sample ones included. Maybe you'll start a small league at your local Ruby meetup. CLI provides easy way to download bots from gists.
+
+Sound difficult or time consuming? It's not! Check out the included sample tank [Seek&Destroy](https://github.com/awilliams/RTanque/blob/master/sample_bots/seek_and_destroy.rb) (which is actually fairly difficult to beat with the keyboard controlled bot). Note that it clocks in at under 50 LOC.
+
+This is not an original idea, see [influences](https://github.com/awilliams/RTanque#influences). There's a lot of resources out there around tank design and tactics that could be applied to RTanque.
+
+How does it look? Here's a video of a battle:
+
+<a href="http://www.youtube.com/watch?feature=player_embedded&v=UPBqwOgGlVY
+" target="_blank"><img src="http://img.youtube.com/vi/UPBqwOgGlVY/0.jpg" 
+alt="RTanque Demo" width="640" height="480" border="10" /></a>
+
+#### Influences
+RTanque is based on the Java project [Robocode](http://robocode.sourceforge.net/) and inspired by other Ruby ports. Thanks and credit go to them both.
+
+* [RobotWar](http://corewar.co.uk/robotwar/) - Perhaps the canonical version. Created in 1970's and set in the distant 2002. Apple II
+* [Robocode](http://robocode.sourceforge.net/) - Java game, originally from IBM. Tank & explosion images taken from here.
+* [RRobots](http://rrobots.rubyforge.org/) - Ruby port of Robocode. 2005
+* [RRobots fork](https://github.com/ralreegorganon/rrobots)
+* [FightCode](http://fightcodegame.com/) - Online javascript tank game
+* [Scalatron](http://scalatron.github.com/) - Scala bot game
+* [Many more...](https://www.google.com/?q=robocode%20clone)
+
+## Requirements
+
+ * The [Gosu](https://github.com/jlnr/gosu) library used for rendering has some dependencies. Use the [Gosu getting started](https://github.com/jlnr/gosu/wiki/Getting-Started-on-Linux) to resolve any for your system.
+ * Ruby 2.0.0 or 1.9.3 (tested on 1.8.7 and 1.9.2)
+
+## Quick Start
+
+Make a project directory, init bundler, add the RTanque gem, and create a bot:
+
+    $ mkdir RTanque; cd RTanque
+    $ bundle init
+    $ echo "gem 'rtanque'" >> Gemfile
+    $ bundle
+    $ bundle exec rtanque new_bot my_deadly_bot
+    $ bundle exec rtanque start bots/my_deadly_bot sample_bots/keyboard sample_bots/camper:x2
+
+*Drive the Keyboard bot with asdf. Aim/fire with the arrow keys*
+
+## [RTanque Documentation](http://rubydoc.info/github/awilliams/RTanque/master/frames/file/README.md)
+
+  * [RTanque](http://rubydoc.info/github/awilliams/RTanque/master/frames/RTanque)
+  * [RTanque::Bot::Brain](http://rubydoc.info/github/awilliams/RTanque/master/frames/RTanque/Bot/Brain)
+  * [RTanque::Heading](http://rubydoc.info/github/awilliams/RTanque/master/frames/RTanque/Heading)
+  * [RTanque::Point](http://rubydoc.info/github/awilliams/RTanque/master/frames/RTanque/Point)
+
+## Advanced Options
+
+Set arena dimensions
+
+    $ bundle exec rtanque start --width=400 --height=400 sample_bots/camper:x4
+
+Adjust max ticks allowed
+
+    $ bundle exec rtanque start --max_ticks=500 sample_bots/camper:x4
+
+Run headless match (no gui)
+
+    $ bundle exec rtanque start --gui=false sample_bots/camper:x4
+
+Run team match (teams are currently determined by bot name. Bots with same name are on the same team. The match finished if alive bots have the same name.) https://github.com/awilliams/RTanque/pull/10
+
+    $ bundle exec rtanque start --teams sample_bots/camper:x4 sample_bots/seek_and_destroy.rb:4
+
+Quiet mode (less console chatter).
+
+    $ bundle exec rtanque start --quiet sample_bots/camper:x4
+
+Set random number seed, allowing same battle to be repeated. https://github.com/awilliams/RTanque/pull/7
+
+    $ bundle exec rtanque start --seed 1234 sample_bots/camper:x4
+
+**Experimental** Disable garbage collection during match
+
+    $ bundle exec rtanque start --gc=false sample_bots/camper:x4
+
+## Sharing
+At some point you'll want to compete against other bots, or maybe you'll even organize a small tournament. Sharing bots is easy.
+
+Ask your friends to upload their bot(s) in a [gist](https://gist.github.com/), which you can then download with the following command:
+
+    bundle exec rtanque get_gist <gist_id> ...
+
+For example, to download [Marksman](https://gist.github.com/SteveRidout/5909793)
+    
+    bundle exec rtanque get_gist 5909793
+    
+If you'd like to publicly share your bot, post its gist id on the wiki https://github.com/awilliams/RTanque/wiki/bot-gists
+
+## Bot API
+
+The tank api consists of reading input from Brain#sensors and giving output to Brain#command
+
+**[Brain#sensors](http://rubydoc.info/github/awilliams/RTanque/master/frames/RTanque/Bot/Sensors)**
+
+```ruby
+class Bot < RTanque::Bot::Brain
+  # RTanque::Bot::Sensors =
+  #  Struct.new(:ticks, :health, :speed, :position, :heading, :radar, :turret)
+  def tick!
+    sensors.ticks # Integer
+    sensors.health # Float
+    sensors.position # RTanque::Point
+    sensors.heading # RTanque::Heading
+    sensors.speed # Float
+    sensors.radar_heading # RTanque::Heading
+    sensors.turret_heading # RTanque::Heading
+    sensors.radar.each do |scanned_bot|
+      # scanned_bot: RTanque::Bot::Radar::Reflection
+      # Reflection(:heading, :distance, :name)
+    end
+  end
+end
+```
+**[Brain#command](http://rubydoc.info/github/awilliams/RTanque/master/frames/RTanque/Bot/Command)**
+
+```ruby
+class Bot < RTanque::Bot::Brain
+  # RTanque::Bot::Command =
+  #  Struct.new(:speed, :heading, :radar_heading, :turret_heading, :fire_power)
+  def tick!
+    command.speed = 1
+    command.heading = Math::PI / 2.0
+    command.radar_heading = Math::PI
+    command.turret_heading = Math::PI
+    command.fire(3)
+  end
+end
+```
+
+**RTanque::Heading**
+This class handles angles. It is a wrapper around Float bound to `(0..Math::PI*2)`
+
+```ruby
+RTanque::Heading.new(Math::PI)
+=> <RTanque::Heading: 3.141592653589793rad 180.0deg>
+
+RTanque::Heading.new_from_degrees(180)
+=> <RTanque::Heading: 3.141592653589793rad 180.0deg>
+
+RTanque::Heading.new_from_degrees(180) + RTanque::Heading.new(Math::PI)
+=> <RTanque::Heading: 0.0rad 0.0deg>
+
+RTanque::Heading.new(Math::PI) + (Math::PI / 2.0)
+=> <RTanque::Heading: 4.71238898038469rad 270.0deg>
+
+RTanque::Heading.new == 0
+=> true
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/rtanque

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'thor'
+require 'rtanque'
+require 'rtanque/runner'
+require 'octokit'
+
+class RTanqueCLI < Thor
+  include Thor::Actions
+  BOT_DIR = 'bots'
+  source_root(File.expand_path('../../', __FILE__))
+
+  desc "start <path_to_brain> <path_to_brain>:x3 ...", "Starts match with given bots"
+  long_desc <<-LONGDESC
+Start an RTanque match. Provide as arguments paths to the brains.
+Note that multiple of the same bot can be loaded by appending ':x<int>' to the path. Eg 'bot/my_bot:x2'
+
+There exist a few sample bots to help get started:
+\x5 * sample_bots/keyboard (special bot controlled with keyboard: a/s/d/f and arrow keys)
+\x5 * sample_bots/seek_and_destroy
+\x5 * sample_bots/camper
+LONGDESC
+  method_option :width, :aliases => '-w', :default => 1200, :type => :numeric, :banner => 'width of window'
+  method_option :height, :aliases => '-h', :default => 700, :type => :numeric, :banner => 'height of window'
+  method_option :max_ticks, :aliases => '-m', :default => Float::INFINITY, :type => :numeric, :banner => 'max ticks allowed per match'
+  method_option :teams, :default => false, :type => :boolean, :banner => 'true to do a team based match based on tank names'
+  method_option :gui, :default => true, :type => :boolean, :banner => 'false to run headless'
+  method_option :gc, :default => true, :type => :boolean, :banner => 'disable GC (EXPERIMENTAL)'
+  method_option :quiet, :aliases => '-q', :default => false, :type => :boolean, :banner => 'disable chatter'
+  method_option :seed, :default => Kernel.srand, :type => :numeric, :banner => 'random number seed value'
+  def start(*brain_paths)
+    Kernel.srand(options[:seed])
+    runner = RTanque::Runner.new(options[:width], options[:height], options[:max_ticks], options[:teams])
+    brain_paths.each { |brain_path|
+      begin
+        runner.add_brain_path(brain_path)
+      rescue RTanque::Runner::LoadError => e
+        say e.message, :red
+        exit false
+      end
+    }
+    self.print_start_banner(runner) unless options[:quiet]
+    self.set_gc(options[:gc]) { runner.start(options[:gui]) }
+    self.print_runner_stats(runner) unless options[:quiet]
+  end
+
+  desc "new_bot <bot_name>", "Creates a new bot"
+  long_desc <<-LONGDESC
+Helper to create a basic brain template in the bots directory
+LONGDESC
+  def new_bot(bot_name)
+    @bot_name = bot_name
+    @bot_class_name = Thor::Util.camel_case(bot_name)
+    template('templates/bot.erb', "#{BOT_DIR}/#{Thor::Util.snake_case(bot_name)}.rb")
+  end
+
+  desc "get_gist <gist_id> <gist_id> ...", "Downloads files from given gist ids into #{BOT_DIR} directory"
+  long_desc <<-LONGDESC
+Helper to download tanks from github gists for easier sharing. Gists can be both 'secret' and 'public'.
+LONGDESC
+  method_option :force, :aliases => '-f', :default => false, :type => :boolean, :banner => 'overwrite existing file without prompt'
+  def get_gist(*gist_ids)
+    gist_ids.each { |gist_id| self.download_gist(gist_id, options) }
+  end
+
+  protected
+
+  def print_start_banner(runner)
+    self.print_stats{ |table|
+      # print options
+      options.each { |opts| table << [set_color(opts[0], :yellow), opts[1].to_s] }
+      # print bots
+      table << [set_color('Bots', :green), runner.match.bots.map { |bot| bot.name }]
+    }
+  end
+
+  def print_runner_stats(runner)
+    say '='*30
+    self.print_stats{ |table|
+      table << [set_color('Ticks', :blue), runner.match.ticks.to_s]
+      table << [set_color('Survivors', :green)] + runner.match.bots.map { |bot| "#{bot.name} [#{bot.health.round}]" }
+    }
+  end
+
+  def set_gc(gc = true)
+    if gc
+      yield
+    else
+      GC.disable
+      begin
+        yield
+      ensure
+        GC.enable
+      end
+    end
+  end
+
+  def download_gist(gist_id, options)
+    client = Octokit::Client.new
+    begin
+      gist = client.gist(gist_id)
+    rescue Octokit::NotFound
+      puts set_color("Error! Gist #{gist_id} not found. Please ensure the gist id is correct.", :red)
+    else
+      gist.files.attrs.each do |name, gist_file|
+        gist_path = "#{BOT_DIR}/#{gist.user.login}.#{gist_id}/#{name}"
+        create_file(gist_path, gist_file.content, options)
+      end
+    end
+  end
+
+  def print_stats(indent = 2, &block)
+    self.print_table([].tap(&block), :indent => indent)
+  end
+end
+
+RTanqueCLI.start

data/lib/rtanque.rb

@@ -0,0 +1,31 @@
+# RTanque
+#
+# #Interesting classes for the spelunker:
+#
+# * {RTanque::Bot::Brain} All brains should inherit from this class
+# * {RTanque::Bot::Sensors} Instance provided to {RTanque::Bot::Brain#sensors}
+# * {RTanque::Bot::Command} Instance provided to {RTanque::Bot::Brain#command}
+# * {RTanque::Heading} Handles angles
+# * {RTanque::Point} Handles coordinates
+module RTanque
+
+end
+
+require 'rtanque/version'
+require 'rtanque/point'
+require 'rtanque/heading'
+require 'rtanque/configuration'
+require 'rtanque/arena'
+require 'rtanque/normalized_attr'
+require 'rtanque/movable'
+require 'rtanque/bot'
+require 'rtanque/bot/radar'
+require 'rtanque/bot/turret'
+require 'rtanque/bot/sensors'
+require 'rtanque/bot/command'
+require 'rtanque/bot/brain'
+require 'rtanque/bot/brain_helper'
+require 'rtanque/explosion'
+require 'rtanque/shell'
+require 'rtanque/match'
+require 'rtanque/match/tick_group'

data/lib/rtanque/arena.rb

@@ -0,0 +1,8 @@
+module RTanque
+  Arena = Struct.new(:width, :height) do
+    def initialize(*args, &block)
+      super
+      self.freeze
+    end
+  end
+end

data/lib/rtanque/bot.rb

@@ -0,0 +1,117 @@
+module RTanque
+  class Bot
+    include Movable
+    extend NormalizedAttr
+    HEALTH_REDUCTION_ON_EXCEPTION = Configuration.bot.health_reduction_on_exception
+    RADIUS = Configuration.bot.radius
+    MAX_GUN_ENERGY = Configuration.bot.gun_energy_max
+    GUN_ENERGY_FACTOR = Configuration.bot.gun_energy_factor
+    attr_reader :arena, :brain, :radar, :turret, :ticks, :health, :fire_power, :gun_energy
+    attr_accessor :gui_window
+    attr_normalized(:speed, Configuration.bot.speed, Configuration.bot.speed_step)
+    attr_normalized(:heading, Heading::FULL_RANGE, Configuration.bot.turn_step)
+    attr_normalized(:fire_power, Configuration.bot.fire_power)
+    attr_normalized(:health, Configuration.bot.health)
+
+    def self.new_random_location(*args)
+      self.new(*args).tap do |bot|
+        rand_heading = Heading.rand
+        bot.position = Point.rand(bot.arena)
+        bot.heading = rand_heading
+        bot.radar.heading = rand_heading
+        bot.turret.heading = rand_heading
+      end
+    end
+
+    def initialize(arena, brain_klass = Brain)
+      @arena = arena
+      @brain = brain_klass.new(self.arena)
+      @ticks = 0
+      self.health = self.class::MAX_HEALTH
+      self.speed = 0
+      self.fire_power = nil
+      self.heading = Heading.new
+      self.position = Point.new(0, 0, self.arena)
+      @radar = Radar.new(self, self.heading.clone)
+      @turret = Turret.new(self.heading.clone)
+    end
+
+    def name
+      @name ||= self.brain.class.const_defined?(:NAME) ? self.brain.class.const_get(:NAME) : [self.brain.class.name, self.object_id].join(':')
+    end
+
+    def health=(val)
+      @health = val
+    end
+
+    def fire_power=(power)
+      @fire_power = power || 0
+    end
+
+    def adjust_fire_power
+      @gun_energy ||= MAX_GUN_ENERGY
+      if @gun_energy <= 0
+        self.fire_power = 0
+      else
+        @gun_energy -= (self.fire_power**RTanque::Shell::RATIO) * GUN_ENERGY_FACTOR
+      end
+      @gun_energy += 1
+      @gun_energy = MAX_GUN_ENERGY if @gun_energy > MAX_GUN_ENERGY
+    end
+
+    def firing?
+      self.fire_power && self.fire_power > 0
+    end
+
+    def reduce_health(reduce_by)
+      self.health -= reduce_by
+    end
+
+    def dead?
+      self.health <= self.class::MIN_HEALTH
+    end
+
+    def tick
+      @ticks += 1
+      self.tick_brain
+      self.adjust_fire_power
+      super
+    end
+
+    def tick_brain
+      begin
+        self.execute_command(self.brain.tick(self.sensors))
+      rescue Exception => brain_error
+        if Configuration.raise_brain_tick_errors
+          raise brain_error
+        else
+          puts brain_error
+          self.reduce_health(HEALTH_REDUCTION_ON_EXCEPTION)
+        end
+      end
+    end
+
+    def execute_command(command)
+      self.fire_power = self.normalize_fire_power(self.fire_power, command.fire_power)
+      self.speed = self.normalize_speed(self.speed, command.speed)
+      self.heading = self.normalize_heading(self.heading, command.heading)
+      self.radar.heading = self.radar.normalize_heading(self.radar.heading, command.radar_heading)
+      self.turret.heading = self.turret.normalize_heading(self.turret.heading, command.turret_heading)
+    end
+
+    def sensors
+      Sensors.new do |sensors|
+        sensors.ticks = self.ticks
+        sensors.health = self.health
+        sensors.speed = self.speed
+        sensors.position = self.position
+        sensors.heading = self.heading
+        sensors.radar = self.radar.to_enum
+        sensors.radar_heading = self.radar.heading
+        sensors.gun_energy = self.gun_energy
+        sensors.turret_heading = self.turret.heading
+        sensors.gui_window = self.gui_window
+      end
+    end
+  end
+end