rtanque 0.0.2

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/.rvmrc

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-2.0.0@RTanque"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.17.2 (stable)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+gemfile: Gemfile.ci
+script: bundle exec rspec
+rvm:
+  - 1.8.7
+  - 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,120 @@
+# 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.
+
+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](https://www.youtube.com/watch?v=G7i5X8pI6dk&hd=1) and screenshot of the game:
+![Battle](https://raw.github.com/awilliams/RTanque/master/screenshots/battle_1.png)
+
+#### 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)
+
+## Bot API
+
+The tank api consists of reading input from Brain#sensors and giving output to Brain#command
+
+**Brain#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**
+
+```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,108 @@
+#!/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 :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'
+  def start(*brain_paths)
+    runner = RTanque::Runner.new(options[:width], options[:height], options[:max_ticks])
+    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)
+    gist = Octokit.gist(gist_id)
+    gist.files.values.map do |gist_file|
+      gist_path = "#{BOT_DIR}/#{gist.user.login}.#{gist_id}/#{gist_file.filename}"
+      create_file(gist_path, gist_file.content, options)
+    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,40 @@
+# 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
+# * {RTanqueCLI} CLI
+module RTanque
+  # @!visibility private
+  def self.round(numeric, precision = nil)
+    if RUBY_VERSION >= '1.9'
+      numeric.round(precision)
+    else
+      # https://github.com/rails/rails/blob/v2.3.8/activesupport/lib/active_support/core_ext/float/rounding.rb
+      precision ? numeric.round : (numeric * (10 ** precision)).round / (10 ** precision).to_f
+    end
+  end
+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