smash_and_grab 0.0.1alpha

data/lib/smash_and_grab.rb

@@ -0,0 +1,107 @@
+require 'optparse'
+
+begin
+  EXTRACT_PATH = File.dirname(File.dirname(File.expand_path(__FILE__)))
+
+  ROOT_PATH = if ENV['OCRA_EXECUTABLE']
+                File.dirname(File.expand_path(ENV['OCRA_EXECUTABLE']))
+              elsif defined? OSX_EXECUTABLE_FOLDER
+                File.dirname(OSX_EXECUTABLE_FOLDER)
+              else
+                EXTRACT_PATH
+              end
+
+  APP_NAME = File.basename(__FILE__).chomp(File.extname(__FILE__))
+
+  RUNNING_FROM_EXECUTABLE = (ENV['OCRA_EXECUTABLE'] or defined?(OSX_EXECUTABLE))
+
+  DEFAULT_LOG_FILE = "#{APP_NAME}.log"
+  DEFAULT_LOG_FILE_PATH = File.join(ROOT_PATH, DEFAULT_LOG_FILE)
+
+  def parse_options
+    options = {}
+
+    OptionParser.new do |parser|
+      parser.banner =<<TEXT
+Usage: #{File.basename(__FILE__)} [options]
+
+  Defaults to using --#{RUNNING_FROM_EXECUTABLE ? 'log' : 'console'}
+
+TEXT
+
+      parser.on('-?', '-h', '--help', 'Display this screen') do
+        puts parser
+        exit
+      end
+
+      options[:dev] = false
+      parser.on('--dev', 'Development mode') do
+        options[:dev] = true
+      end
+
+      parser.on('--console', 'Console mode (no log file)') do
+        options[:log] = nil # Write to console.
+      end
+
+      parser.on('--log [FILE]', "Write log to a file (defaults to '#{DEFAULT_LOG_FILE}')") do |file|
+        options[:log] = file ? file : DEFAULT_LOG_FILE_PATH
+      end
+
+      parser.on('--timestamp', "Adds a timestamp to the log file") do
+        options[:timestamp] = true
+      end
+
+      begin
+        parser.parse!
+      rescue OptionParser::ParseError => ex
+        puts "ERROR: #{ex.message}"
+        puts
+        puts parser
+        exit
+      end
+    end
+
+    options
+  end
+
+  options = parse_options
+
+  # Default to console mode normally; default to logfile when running executable.
+  if RUNNING_FROM_EXECUTABLE and not options.has_key?(:log)
+    options[:log] = DEFAULT_LOG_FILE_PATH
+  end
+
+  LOG_FILE = options[:log]
+  DEVELOPMENT_MODE = options[:dev]
+
+  ENV['PATH'] = File.join(EXTRACT_PATH, 'bin') + File::PATH_SEPARATOR + ENV['PATH']
+
+  if LOG_FILE
+    # Add a timestamp to the end of the log file-name.
+    if options[:timestamp]
+      LOG_FILE.sub!(/(\.\w+)$/, "_#{Time.now.to_s.gsub(/[^\d]/, "_")}_#{Time.now.usec.to_s.rjust(6, '0')}\\1")
+    end
+
+    puts "Redirecting output to '#{LOG_FILE}'"
+
+    original_stderr = $stderr.dup
+    $stderr.reopen LOG_FILE
+    $stderr.sync = true
+
+    original_stdout = $stdout.dup
+    $stdout.reopen LOG_FILE
+    $stdout.sync = true
+  end
+
+  require_relative "smash_and_grab/main"
+
+  exit_message = ""
+
+rescue => ex
+  $stderr.puts "FATAL ERROR - #{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}"
+  raise ex # Just to make sure that the user sees the error in the CLI/IDE too.
+ensure
+  $stderr.reopen(original_stderr) if defined?(original_stderr) and original_stderr
+  $stderr.puts exit_message if exit_message
+  $stdout.reopen(original_stdout) if defined?(original_stdout) and original_stdout
+end

data/media/fonts/fontinfo.txt

@@ -0,0 +1,25 @@
+This font is � 2010 Nate Piekos.  All Rights Reserved.  
+Created for Blambot Fonts
+
+This font is freeware for independent comic book creation and 
+non-profit use ONLY. This excludes use by "mainstream" publishers
+(Marvel, DC, Dark Horse, Oni, Image, SLG, Top Cow, Crossgen and their 
+subsidiaries) without a license fee. Use by a "mainstream" publisher 
+(or its employee) and use for commercial non-comic book production 
+(e.g. magazine ads, merchandise labels) requires a license fee
+be paid to the designer, Nate Piekos. 
+This font may not be redistributed without the author's permission and
+must always include this text file in the .zip, .sit or .hqx.
+
+Blambot/Nate Piekos makes no guarantees about these font files,
+ the completeness of character sets, or safety of these files on your
+computer.  By installing these fonts on your system, you prove that 
+you have read and understand the above.
+
+If you have any questions, visit http://www.blambot.com/license.shtml
+
+For more free and original fonts visit Blambot.
+www.blambot.com
+
+Nate Piekos
+studio@blambot.com

data/smash_and_grab.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "smash_and_grab/version"
+
+Gem::Specification.new do |s|
+  s.name = "smash_and_grab"
+  s.version = SmashAndGrab::VERSION
+
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bil Bas (Spooner)"]
+  s.email       = ["bil.bagpuss@gmail.com"]
+  s.homepage    = "http://spooner.github.com/games/smash_and_grab/"
+  s.summary     = %q{Turn-based isometric heist game}
+  s.description = <<END
+#{s.summary}
+END
+
+  s.files = `git ls-files`.split("\n").reject {|f| f =~ /^(?:\.|raw_media|build)/ }
+  s.licenses = ["MIT"]
+  s.rubyforge_project = "smash_and_grab"
+
+  s.executable = "smash_and_grab"
+  s.test_files = Dir["test/**/*_test.rb"]
+  s.required_ruby_version = "~> 1.9.2"
+
+  s.add_runtime_dependency "gosu", "~> 0.7.41"
+  s.add_runtime_dependency "chingu", "~> 0.9rc7"
+  s.add_runtime_dependency "fidgit", "~> 0.1.10"
+  s.add_runtime_dependency "texplay", "~> 0.3"
+  #s.add_runtime_dependency "r18n-desktop", "~> 0.4.9"
+
+  s.add_development_dependency "releasy", "~> 0.2.2"
+  s.add_development_dependency "rake", "~> 0.9.2.2"
+  s.add_development_dependency "bacon-rr", "~> 0.1.0"
+end

data/test/smash_and_grab/abilities/helpers/ability_helper.rb

@@ -0,0 +1,6 @@
+shared SmashAndGrab::Abilities::Ability do
+  should "behave like an Abilities::Ability" do
+    subject.should.be.kind_of SmashAndGrab::Abilities::Ability
+    [true, false].should.include subject.can_be_undone?
+  end
+end

data/test/smash_and_grab/abilities/melee_test.rb

@@ -0,0 +1,105 @@
+require_relative "../../teststrap"
+require_relative "helpers/ability_helper"
+
+describe SmashAndGrab::Abilities::Melee do
+  helper(:entity) {@entity ||= Object.new }
+  helper(:enemy) { @enemy ||= Object.new }
+  helper(:tile) { @tile ||= SmashAndGrab::Tile.new(:grass, nil, 1, 1) }
+
+  subject { SmashAndGrab::Abilities.ability entity, type: :melee, action_cost: 1, skill: 5 }
+
+  behaves_like SmashAndGrab::Abilities::Ability
+
+  should "fail if not given the required arguments" do
+    ->{ SmashAndGrab::Abilities.ability entity, type: :melee }.should.raise(ArgumentError).message.should.match /No skill value for/
+  end
+
+  should "be initialized" do
+    subject.owner.should.equal entity
+    subject.can_be_undone?.should.be.false
+    subject.skill.should.equal 5
+    subject.action_cost.should.equal 1
+  end
+
+  should "serialize to json correctly" do
+    JSON.parse(subject.to_json).symbolize.should.equal(
+        type: :melee,
+        skill: 5,
+        action_cost: 1
+    )
+  end
+
+  should "generate appropriate action_data" do
+    stub(entity).id.returns 12
+    stub(enemy).id.returns 13
+    stub(tile).object.returns enemy
+    stub(subject).random_damage.returns 5
+    subject.action_data(tile).should.equal(
+        ability: :melee,
+        skill: 5,
+        action_cost: 1,
+
+        owner_id: 12,
+        target_id: 13,
+        target_position: [1, 1],
+        damage: 5
+    )
+  end
+
+  describe "#random_damage" do
+    should "never give a value greater than skill" do
+      stub(subject).rand(is_a(Integer)) {|x| x - 1 }
+      subject.random_damage == 5
+    end
+
+    should "never give a value less than 1" do
+      stub(subject).rand(is_a(Integer)) { 0 }
+      subject.random_damage == 1
+    end
+  end
+
+  describe "#do" do
+    should "remove action points and health" do
+      stub(enemy).health.returns 20
+      mock(enemy, :health=).with 15
+
+      stub(entity).map.stub!.object_by_id(13).returns enemy
+      stub(entity).action_points.returns 1
+      mock(entity, :action_points=).with 0
+
+      subject.do action_cost: 1, target_id: 13, damage: 5 #, target_position: [1, 1]
+      true
+    end
+  end
+
+  describe "#undo" do
+    should "give action points and health (if target alive)" do
+      stub(enemy).tile.returns tile
+      stub(enemy).health.returns 15
+      mock(enemy, :health=).with 20
+
+      stub(entity).map.stub!.object_by_id(13).returns enemy
+      stub(entity).action_points.returns 0
+      mock(entity, :action_points=).with 1
+
+      subject.undo action_cost: 1, target_id: 13, damage: 5, target_position: [1, 1]
+    end
+
+    should "give action points, health and return to map (if target dead)" do
+      stub(enemy).tile.returns nil
+      stub(enemy).health.returns 0
+      mock(enemy, :tile=).with tile
+      mock(enemy, :health=).with 5
+
+      stub(entity).map do
+        map = Object.new
+        stub(map).object_by_id(13).returns enemy
+        stub(map).tile_at_grid([1, 1]).returns tile
+      end
+      stub(entity).action_points.returns 0
+      mock(entity, :action_points=).with 1
+
+      subject.undo action_cost: 1, target_id: 13, damage: 5, target_position: [1, 1]
+    end
+  end
+end

data/test/smash_and_grab/abilities/move_test.rb

@@ -0,0 +1,87 @@
+require_relative "../../teststrap"
+require_relative "helpers/ability_helper"
+
+describe SmashAndGrab::Abilities::Move do
+  helper :tile do |i|
+    @tiles ||= Hash.new do |hash, key|
+      hash[key] = SmashAndGrab::Tile.new(:grass, nil, 0, key)
+    end
+    @tiles[i]
+  end
+
+  helper(:entity) { @entity ||= Object.new }
+  helper(:tiles) { [tile(0), tile(1), tile(2)] }
+  helper(:tile_positions) { tiles.map {|t| t.grid_position } }
+
+  subject { SmashAndGrab::Abilities.ability entity, type: :move }
+
+  behaves_like SmashAndGrab::Abilities::Ability
+
+  should "be initialized" do
+    subject.owner.should.equal entity 
+    subject.can_be_undone?.should.be.true
+    subject.skill.should.equal 0
+    subject.action_cost.should.equal 0
+  end
+
+  should "serialize to json correctly" do
+    JSON.parse(subject.to_json).symbolize.should.equal(
+        type: :move,
+        skill: 0, # TODO: Irrelevant for move?
+        action_cost: 0 # TODO: Irrelevant for move? Not sure; perhaps some entities can move OR attack?
+    )
+  end
+
+  should "generate appropriate action_data" do
+    stub(subject.owner).id.returns 12 # Don't know why I need to repeat this.
+    path = Object.new
+    mock(path).tiles.returns tiles
+    mock(path).move_distance.returns 3
+    mock(path).last.returns tiles.last
+    mock(tiles.last).object.returns nil
+    subject.action_data(path).should.equal(
+        ability: :move,
+        skill: 0, # TODO: Irrelevant for move?
+        action_cost: 0, # TODO: Irrelevant for move? Not sure; perhaps some entities can move OR attack?
+  
+        owner_id: 12,
+        movement_cost: 3,
+        target_id: nil, # TODO: Irrelevant for move?
+        target_position: [0, 2], # TODO: Irrelevant for move?
+        path: [[0, 0], [0, 1], [0, 2]]
+    )
+  end
+
+  describe "#target_valid?" do
+    should "if target contains an object" do
+      mock(tile(2)).empty?.returns false
+      subject.target_valid?(tile(2)).should.be.false
+    end
+
+    should "if target is an empty tile without a path" do
+      mock(tile(2)).empty?.returns true
+      mock(entity).path_to(tile(2)).returns nil
+      subject.target_valid?(tile(2)).should.be.false
+    end
+
+    should "if target is an empty tile with a path" do
+      mock(tile(2)).empty?.returns true
+      mock(entity).path_to(tile(2)).returns tiles
+      subject.target_valid?(tile(2)).should.be.true
+    end
+  end
+
+  describe "#do" do
+    should "move the entity forwards" do
+      mock(entity).move tile_positions, 4
+      subject.do action_cost: 0, path: tile_positions, movement_cost: 4
+    end
+  end
+
+  describe "#undo" do
+    should "move the entity backwards" do
+      mock(entity).move tile_positions.reverse, -4
+      subject.undo action_cost: 0, path: tile_positions, movement_cost: 4
+    end
+  end
+end

data/test/smash_and_grab/abilities/sprint_test.rb

@@ -0,0 +1,75 @@
+require_relative "../../teststrap"
+require_relative "helpers/ability_helper"
+
+describe SmashAndGrab::Abilities::Sprint do
+  helper(:entity) { @entity ||= Object.new }
+
+  subject { SmashAndGrab::Abilities.ability entity, type: :sprint, skill: 3 }
+
+  behaves_like SmashAndGrab::Abilities::Ability
+
+  should "fail if not given the required arguments" do
+    ->{ SmashAndGrab::Abilities.ability entity, type: :sprint }.should.raise(ArgumentError).message.should.match /No skill value for/
+  end
+
+  should "be initialized" do
+    subject.owner.should.equal entity
+    subject.can_be_undone?.should.be.true
+    subject.skill.should.equal 3
+
+    stub(entity).max_action_points.returns 2
+    subject.action_cost.should.equal 2
+  end
+
+  should "serialize to json correctly" do
+    JSON.parse(subject.to_json).symbolize.should.equal(
+      type: :sprint,
+      skill: 3,
+      action_cost: :all,
+    )
+  end
+
+  should "generate appropriate action_data" do
+    mock(entity).id.returns 12
+    mock(entity).max_movement_points.returns 11
+    mock(entity).max_action_points.returns 2
+    subject.action_data.should.equal(
+      ability: :sprint,
+      skill: 3,
+      action_cost: 2,
+
+      owner_id: 12,
+      movement_bonus: 5
+    )
+  end
+
+  describe "owner has max_mp == 100" do
+    { 1 => 1, 2 => 25, 3 => 50, 4 => 75, 5 => 100 }.each do |skill, expected_bonus|
+      should "have #movement_bonus == #{expected_bonus} with #skill == #{skill}" do
+        mock(entity).max_movement_points.returns 100
+        mock(subject).skill.returns skill
+        subject.movement_bonus.should.equal expected_bonus
+      end
+    end
+  end
+
+  describe "#do" do
+    should "increase movement points and decrease action points" do
+      stub(entity).action_points.returns 2
+      mock(entity, :action_points=).with 0
+      mock(entity).movement_points.returns 5
+      mock(entity, :movement_points=).with 10
+      subject.do action_cost: 2, movement_bonus: 5
+    end
+  end
+
+  describe "#undo" do
+    should "decrease movement points and increase action points" do
+      stub(entity).action_points.returns 0
+      mock(entity, :action_points=).with 2
+      stub(entity).movement_points.returns 10
+      mock(entity, :movement_points=).with 5
+      subject.undo action_cost: 2, movement_bonus: 5
+    end
+  end
+end

data/test/smash_and_grab/map/faction_test.rb

@@ -0,0 +1,62 @@
+require_relative "../../teststrap"
+
+shared SmashAndGrab::Factions::Faction do
+  should "not be active" do
+    subject.should.not.be.active
+  end
+
+  should "have no entities" do
+    subject.entities.should.be.kind_of Array
+    subject.entities.should.be.empty
+  end
+end
+
+describe SmashAndGrab::Factions::Faction do
+  helper(:baddies) { SmashAndGrab::Factions::Baddies.new nil }
+  helper(:goodies) { SmashAndGrab::Factions::Goodies.new nil }
+  helper(:bystanders) { SmashAndGrab::Factions::Bystanders.new nil }
+
+  subject { described.new nil }
+
+  describe SmashAndGrab::Factions::Goodies do
+    behaves_like SmashAndGrab::Factions::Faction
+
+    should "dislike baddies" do
+      subject.should.be.enemy? baddies
+      subject.should.not.be.friend? baddies
+    end
+
+    should "like bystanders" do
+      subject.should.not.be.enemy? bystanders
+      subject.should.be.friend? bystanders
+    end
+  end
+
+  describe SmashAndGrab::Factions::Baddies do
+    behaves_like SmashAndGrab::Factions::Faction
+
+    should "dislike goodies" do
+      subject.should.be.enemy? goodies
+      subject.should.not.be.friend? goodies
+    end
+
+    should "dislike bystanders" do
+      subject.should.be.enemy? bystanders
+      subject.should.not.be.friend? bystanders
+    end
+  end
+
+  describe SmashAndGrab::Factions::Bystanders do
+    behaves_like SmashAndGrab::Factions::Faction
+
+    should "like goodies" do
+      subject.should.not.be.enemy? goodies
+      subject.should.be.friend? goodies
+    end
+
+    should "dislike baddies" do
+      subject.should.be.enemy? baddies
+      subject.should.not.be.friend? baddies
+    end
+  end
+end

data/test/smash_and_grab/map/map_test.rb

@@ -0,0 +1,114 @@
+require_relative "../../teststrap"
+
+describe SmashAndGrab::Map do
+  helper :objects_data do
+    [
+        {
+            "class" => "entity",
+            "type" => "professor_goggles",
+            "id" => 0,
+            "health" => 8,
+            "movement_points" => 7,
+            "action_points" => 1,
+            "facing" => "left",
+            "tile" => [
+                1,
+                0
+            ],
+        },
+        {
+            "class"  => "object",
+            "type" => "tree",
+            "id" => 1,
+            "tile" => [
+                0,
+                1
+            ]
+        }
+    ]
+  end
+
+  helper :walls_data do
+    [
+        {
+            "type" => "low_fence",
+            "tiles" => [
+                [
+                    0,
+                    0
+                ],
+                [
+                    0,
+                    1
+                ]
+            ]
+        }
+    ]
+  end
+
+  helper :tiles_data do
+    [
+        ['grass', 'concrete'],
+        ['dirt', 'dirt'],
+    ]
+  end
+
+  helper :map_data do
+    {
+        'tiles' => tiles_data,
+        'objects' => objects_data,
+        'actions' => [],
+        'walls' => walls_data
+    }
+  end
+
+  subject { SmashAndGrab::Map.new map_data.symbolize }
+
+  describe "#tile_at_grid" do
+    should "find the correct tile" do
+      subject.tile_at_grid(0, 0).type.should.equal :grass
+      subject.tile_at_grid(1, 0).type.should.equal :concrete
+    end
+    
+    should "return nil for positions outside the grid" do
+      subject.tile_at_grid(-1, 0).should.be.nil
+      subject.tile_at_grid(2, 0).should.be.nil
+    end
+  end
+
+  describe "#tile_at_position" do
+    should "find the correct tile" do
+      subject.tile_at_position(0, 0).type.should.equal :grass
+      subject.tile_at_position(4, 8).type.should.equal :dirt
+    end
+
+    should "return nil outside the grid" do
+      subject.tile_at_position(-8, -8).should.be.nil
+      subject.tile_at_position(64, 0).should.be.nil
+    end
+  end
+
+  describe "#objects" do
+    should "give correct object" do
+      subject.object_by_id(0).id.should.equal 0
+      subject.object_by_id(1).id.should.equal 1
+    end
+
+    should "raise error with bad id" do
+      ->{ subject.object_by_id(-1) }.should.raise(RuntimeError)
+      ->{ subject.object_by_id(2) }.should.raise(RuntimeError)
+    end
+  end
+
+  describe "#save_data" do
+    subject { SmashAndGrab::Map.new(map_data.symbolize).save_data }
+
+    should "contain the same data as was loaded" do
+      subject[:version].should.equal SmashAndGrab::VERSION
+      subject[:map_size].should.equal [2, 2]
+      JSON.parse(subject[:tiles].to_json).should.equal tiles_data
+      JSON.parse(subject[:walls].to_json).should.equal walls_data
+      JSON.parse(subject[:objects].to_json).should.equal objects_data
+    end
+  end
+end

data/test/smash_and_grab/map/tile_test.rb

@@ -0,0 +1,17 @@
+require_relative "../../teststrap"
+
+describe SmashAndGrab::Tile do
+  subject { described.new :grass, nil, 0, 0 }
+
+  should "have correct initial state" do
+    subject.type.should.equal :grass
+    subject.x.should.equal 0
+    subject.y.should.equal 0
+    subject.grid_x.should.equal 0
+    subject.grid_y.should.equal 0
+    subject.minimap_color.should.be.kind_of Gosu::Color
+    subject.movement_cost.should.be.kind_of Integer
+    subject.image.should.be.kind_of Gosu::Image
+    subject.to_json.should.equal "\"grass\""
+  end
+end

data/test/smash_and_grab/map/wall_test.rb

@@ -0,0 +1,5 @@
+require_relative "../../teststrap"
+
+describe SmashAndGrab::Wall do
+
+end