battle_royal 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d5a69a461cf3ee8f5718cc78cda04e54099256d
+  data.tar.gz: a74cf3cccc3d1f191378d1ed34ced29699e004dd
+SHA512:
+  metadata.gz: 6463afd892bbcfa7b9c36ff8ddfaefb8907b0bc3a7fbf7617b19b2027d4a0aa85d0a2fdad51f966d4adb32d66f7c733bbcec7c9f22dc64feef1e356adc5d0209
+  data.tar.gz: c74e2e2728c4df57e249749d921086f8e00e8c79fef96e3cdede2c021521254e052a80e70947e48e4b7f07b9d5cf7ab225d155f136b9af90503e42b502a89981

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Shane Barringer
+
+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,19 @@
+## battle royal
+A Mortal Kombat influenced battle royal gem
+
+### To Use
+run `gem install battle_royal`
+
+In your terminal simply run `$ battle`
+
+### Notes
+
+Currently, the game allows for users to input a certain number of rounds. The battle will run until there is only 1 player standing.
+I recommend that you run the game for at least 10 - 100 rounds
+
+
+### To Contribute
+1. Fork
+2. Clone
+3. Create a New Branch
+4. Submit a Pull Request

data/bin/battle

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/battle_royal/game'
+
+puts 'Welcome to the Battle Royal. Please enter a name for the competition: '
+name = gets.chomp.capitalize
+
+throwdown = BattleRoyal::Game.new(name.empty? ? 'Throwdown' : name)
+
+default_players_file = File.join(File.dirname(__FILE__), 'csv/favorite_players.csv')
+throwdown.load_players(ARGV.shift || default_players_file)
+lame = BattleRoyal::LamePlayer.new('Stryker', 105, 5)
+throwdown.add_player(lame)
+awesome = BattleRoyal::AdvantagedPlayer.new('Scorpion', 120)
+throwdown.add_player(awesome)
+puts "#{throwdown.title} Begin!"
+
+loop do
+  puts "\nHow many rounds would you like to play? (type 'quit' to exit)"
+  rounds = gets.chomp.downcase
+
+  case rounds
+  when  /^\d+$/
+    throwdown.play(rounds.to_i) # { throwdown.total_points >= 10_000 }
+  when  'quit', 'exit', 'n'
+    throwdown.result
+    throwdown.winning
+    break
+  else
+    puts 'please enter a number'
+    sleep(1)
+  end
+end
+
+throwdown.save_high_scores

data/bin/csv/favorite_players.csv

@@ -0,0 +1,3 @@
+Sub Zero,100
+Reptile,140
+Raiden, 160

data/bin/csv/players.csv

@@ -0,0 +1,3 @@
+Noob Saibot,100
+Liu Kang,60
+Kung Lao,125

data/lib/battle_royal/advantaged_player.rb

@@ -0,0 +1,29 @@
+require_relative 'player'
+module BattleRoyal
+  class AdvantagedPlayer < Player
+    def initialize(name, health = 100)
+      super(name, health)
+      @power_up_count = 0
+    end
+
+    def advantaged?
+      @power_up_count > 5
+    end
+
+    def power_up
+      super
+      @power_up_count += 1
+      puts "#{@name} is advantaged!" if advantaged?
+    end
+
+    def damage
+      advantaged? ? power_up : super
+    end
+  end
+
+  if __FILE__ == $PROGRAM_NAME
+    advantaged = AdvantagedPlayer.new('advantaged', 50)
+    6.times { advantaged.power_up }
+    2.times { advantaged.damage }
+  end
+end

data/lib/battle_royal/game.rb

@@ -0,0 +1,118 @@
+require_relative 'player'
+require_relative 'roll'
+require_relative 'weapon_chest'
+require_relative 'lame_player'
+require_relative 'advantaged_player'
+require 'csv'
+module BattleRoyal
+  class Game
+    attr_accessor :title, :players, :toasty
+    def initialize(title)
+      @title = title
+      @players = [].sort
+      @total_points = 0
+      @toasty = []
+    end
+
+    def add_player(player)
+      @players << player
+    end
+
+    def load_players(some_file)
+      CSV.foreach(some_file).each do |line|
+        add_player(Player.from_csv(line))
+      end
+    end
+
+    def save_high_scores
+      File.open("#{title}.txt", 'w') do |file|
+        file.puts "#{@title} High Scores:"
+        @players.sort_by(&:score).reverse_each do |player|
+          file.puts sort_and_score(player)
+        end
+      end
+    end
+
+    def start_of_game
+      puts "There are #{@players.size} players and #{WeaponChest::WEAPONS.count} weapons available in this game: "
+
+      WeaponChest::WEAPONS.each { |x| puts "A #{x.name} is worth #{x.points} points" }
+    end
+
+    def attack_player
+      @players.sample
+    end
+
+    def fatality?(player)
+      player.health < 0
+    end
+
+    def play(rounds)
+      start_of_game
+      1.upto(rounds) do
+        # if a block is given AND the block returns true, break out of loop.
+        break if yield if block_given?
+        if @players.count > 1
+          @players.shuffle.each do |player|
+            if !fatality?(player)
+              Roll.turn(player)
+              sleep(0.5)
+              player.attack(attack_player, player.found_weapon(Roll.weapon(player)))
+              sleep(0.5)
+              player.points
+            elsif fatality?(player)
+              @toasty << @players.find { |x| x == player }
+              puts "\n#{player.name} is no longer with us"
+              @players.delete(player)
+              sleep(0.5)
+            end
+          end
+        else
+          puts "\n#{@players[0].name.upcase} IS THE LAST MAN STANDING!!! "
+          break
+        end
+      end
+      @players |= @toasty
+    end
+
+    def print_player_and_health(criteria)
+      criteria.sort_by(&:score).reverse_each do |player|
+        puts "\n#{player.name}'s point totals: "
+        player.each_found_weapon do |weapon|
+          puts "#{weapon.points} total #{weapon.name} points"
+        end
+        puts "#{player.points} grand total points"
+        puts "health: #{player.health}"
+      end
+    end
+
+    def result
+      stronger, weaker = @players.partition(&:strong?)
+      puts "\n Statistics:"
+
+      puts "\n#{stronger.size} strong players:"
+      print_player_and_health(stronger)
+
+      puts "\n#{weaker.size} weaker players:"
+      print_player_and_health(weaker)
+
+      puts "\n#{total_points} total points for this match"
+    end
+
+    def winning
+      puts "\nScoreboard: "
+      @players.sort_by(&:score).reverse_each do |player|
+        puts sort_and_score(player)
+      end
+    end
+
+    def sort_and_score(player)
+      formatted_name = player.name.ljust(20, '.')
+      "#{formatted_name} #{player.score}"
+    end
+
+    def total_points
+      @players.inject(0) { |sum, player| sum + player.points }
+    end
+  end
+end

data/lib/battle_royal/lame_player.rb

@@ -0,0 +1,35 @@
+require_relative 'player'
+module BattleRoyal
+  class LamePlayer < Player
+    def initialize(name, health = 100, boost = 1)
+      super(name, health)
+      @boost = boost
+    end
+
+    def found_weapon(weapon)
+      damaged_weapon = Weapon.new(weapon.name, weapon.points / 2)
+      super(damaged_weapon)
+    end
+
+    def power_up
+      @boost.times { super }
+    end
+  end
+
+  if __FILE__ == $PROGRAM_NAME
+    lame = LamePlayer.new('klutz')
+
+    axe = Weapon.new(:axe, 50)
+    lame.found_weapon(axe)
+    lame.found_weapon(axe)
+    lame.found_weapon(axe)
+
+    sabre = Weapon.new(:sabre, 400)
+    lame.found_weapon(sabre)
+
+    lame.each_found_weapon do |weapon|
+      puts "#{weapon.points} total #{weapon.name} points"
+    end
+    puts "#{lame.points} grand total points"
+  end
+end

data/lib/battle_royal/playable.rb

@@ -0,0 +1,17 @@
+module BattleRoyal
+  module Playable
+    def power_up
+      self.health += 15
+      puts "\n#{name} got a power up!"
+    end
+
+    def damage
+      self.health -= 10
+      puts "\n#{name} got damaged and now has a health of #{health}"
+    end
+
+    def strong?
+      self.health >= 100
+    end
+  end
+end

data/lib/battle_royal/player.rb

@@ -0,0 +1,61 @@
+require_relative 'weapon_chest'
+require_relative 'playable'
+module BattleRoyal
+  class Player
+    include Playable
+
+    attr_accessor :name, :health
+    def initialize(name, health = 100)
+      @name = name.capitalize
+      @health = health
+      @found_weapons = Hash.new(0)
+    end
+
+    def to_s
+      "#{@name} health = #{@health}, points = #{points}, and score = #{score}"
+    end
+
+    def self.from_csv(string)
+      Player.new(string[0], string[1].to_i)
+    end
+
+    def found_weapon(weapon)
+      @found_weapons[weapon.name] += weapon.points
+      print "\n#{@name} found a #{weapon.name} worth #{weapon.points} damage points"
+
+      @found_weapons[weapon.name]
+    end
+
+    def attack(player, found_weapon)
+      @health = health - found_weapon
+      print " and attacked #{player.name} \n"
+      sleep(0.5)
+      puts "#{player.name}'s health is now: #{player.health} \n"
+    end
+
+    def points
+      @found_weapons.values.inject(0, :+)
+    end
+
+    def each_found_weapon
+      @found_weapons.each do |name, points|
+        yield Weapon.new(name, points)
+      end
+    end
+
+    def score
+      points + @health
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  # part of the readme
+  player = Player.new('Scorpion')
+  puts player.name
+  puts player.health
+  player.power_up
+  puts player.health
+  player.damage
+  puts player.health
+end

data/lib/battle_royal/roll.rb

@@ -0,0 +1,16 @@
+module BattleRoyal
+  module Roll
+    def self.actions
+      [:power_up, :damage, nil]
+    end
+
+    def self.turn(player)
+      action = actions.sample
+      !action.nil? ? player.send(action) : puts("\n#{player.name} missed a turn")
+    end
+
+    def self.weapon(_player)
+      WeaponChest.random
+    end
+  end
+end

data/lib/battle_royal/weapon_chest.rb

@@ -0,0 +1,18 @@
+module BattleRoyal
+  Weapon = Struct.new(:name, :points)
+
+  module WeaponChest
+    WEAPONS = [
+      Weapon.new("throwing star".to_sym, 5),
+      Weapon.new(:staff, 25),
+      Weapon.new(:axe, 50),
+      Weapon.new(:mace, 100),
+      Weapon.new(:katana, 200),
+      Weapon.new(:sabre, 400)
+    ]
+
+    def self.random
+      WEAPONS.sample
+    end
+  end
+end

data/spec/battle_royal/advantaged_player_spec.rb

@@ -0,0 +1,26 @@
+require 'battle_royal/advantaged_player'
+module BattleRoyal
+  describe AdvantagedPlayer do
+    before do
+      @initial_health = 50
+      @player = AdvantagedPlayer.new('advantaged', @initial_health)
+    end
+
+    it 'does not go advantaged when power_uped up to 5 times' do
+      1.upto(5) { @player.power_up }
+      expect(@player.advantaged?).to be_falsey
+    end
+
+    it 'goes advantaged when power_uped more than 5 times' do
+      1.upto(6) { @player.power_up }
+      expect(@player.advantaged?).to be_truthy
+    end
+
+    it "gets power_uped instead of damagemed when it's gone advantaged" do
+      1.upto(6) { @player.power_up }
+      1.upto(2) { @player.damage }
+
+      expect(@player.health).to be(@initial_health + (8 * 15))
+    end
+  end
+end

data/spec/battle_royal/game_spec.rb

@@ -0,0 +1,21 @@
+require 'battle_royal/game'
+module BattleRoyal
+  describe Game do
+    it 'computes total points as the sum of all player points' do
+      $stdout = StringIO.new
+      game = Game.new('battle')
+
+      player1 = Player.new('scorpion')
+      player2 = Player.new('stryker')
+
+      game.add_player(player1)
+      game.add_player(player2)
+
+      player1.found_weapon(Weapon.new(:axe, 50))
+      player1.found_weapon(Weapon.new(:axe, 50))
+      player2.found_weapon(Weapon.new(:sabre, 400))
+
+      expect(game.total_points).to eq(500)
+    end
+  end
+end

data/spec/battle_royal/lame_player_spec.rb

@@ -0,0 +1,31 @@
+require 'battle_royal/lame_player'
+module BattleRoyal
+  describe LamePlayer do
+    before do
+      @player = LamePlayer.new('stryker')
+    end
+
+    it 'only gets half the point value for each weapon' do
+      expect(@player.points).to eq(0)
+
+      axe = Weapon.new(:axe, 50)
+      @player.found_weapon(axe)
+      @player.found_weapon(axe)
+      @player.found_weapon(axe)
+
+      expect(@player.points).to eq(75)
+
+      sabre = Weapon.new(:sabre, 400)
+      @player.found_weapon(sabre)
+
+      expect(@player.points).to eq(275)
+
+      yielded = []
+      @player.each_found_weapon do |weapon|
+        yielded << weapon
+      end
+
+      expect(yielded).to eq([Weapon.new(:axe, 75), Weapon.new(:sabre, 200)])
+    end
+  end
+end

data/spec/battle_royal/player_spec.rb

@@ -0,0 +1,108 @@
+require 'battle_royal/player'
+require 'battle_royal/weapon_chest'
+
+module BattleRoyal
+  describe Player do
+    before do
+      # removes string output for power_up and damage methods while spec is running(only)
+      $stdout = StringIO.new
+
+      @initial_health = 150
+      @player = Player.new('stryker', @initial_health)
+    end
+
+    def found_weapon
+      @player.found_weapon(Weapon.new(:axe, 50))
+    end
+    it 'has a capitalized name' do
+      expect(@player.name).to eq('Stryker')
+    end
+
+    it 'has an initial health' do
+      expect(@player.health).to eq(150)
+    end
+
+    it 'has a string representation' do
+      2.times { found_weapon }
+
+      expect(@player.to_s).to eq('Stryker health = 150, points = 100, and score = 250')
+    end
+
+    it 'computes a score as the sum of its health and points' do
+      2.times { found_weapon }
+
+      expect(@player.score).to eq(250)
+    end
+
+    it 'increases health by 15 when power_uped' do
+      @player.power_up
+      expect(@player.health).to eq(@initial_health + 15)
+    end
+
+    it 'decreases health by 10 when damagemed' do
+      @player.damage
+      expect(@player.health).to eq(@initial_health - 10)
+    end
+
+    context 'player has health of 150' do
+      before do
+        @initial_health = 150
+        @player = Player.new('stryker', @initial_health)
+      end
+
+      it 'returns true if player is strong' do
+        expect(@player).to be_strong
+      end
+    end
+
+    context 'player has health of 100 or less' do
+      before do
+        @initial_health = 99
+        @player = Player.new('scorpion', @initial_health)
+      end
+
+      it 'returns false if player health is less 100 or less' do
+        expect(@player).not_to be_strong
+      end
+    end
+    context 'players collect weapons' do
+      it 'computes points as the sum of all weapon points' do
+        expect(@player.points).to eq(0)
+
+        @player.found_weapon(Weapon.new(:axe, 50))
+
+        expect(@player.points).to eq(50)
+
+        @player.found_weapon(Weapon.new(:sabre, 400))
+
+        expect(@player.points).to eq(450)
+
+        @player.found_weapon(Weapon.new(:axe, 50))
+
+        expect(@player.points).to eq(500)
+      end
+    end
+
+    it 'yields each found weapon and its total points' do
+      @player.found_weapon(Weapon.new(:mace, 100))
+      @player.found_weapon(Weapon.new(:mace, 100))
+      @player.found_weapon(Weapon.new(:axe, 50))
+      @player.found_weapon(Weapon.new(:staff, 5))
+      @player.found_weapon(Weapon.new(:staff, 5))
+      @player.found_weapon(Weapon.new(:staff, 5))
+      @player.found_weapon(Weapon.new(:staff, 5))
+      @player.found_weapon(Weapon.new(:staff, 5))
+
+      yielded = []
+      @player.each_found_weapon do |weapon|
+        yielded << weapon
+      end
+
+      expect(yielded).to eq([
+        Weapon.new(:mace, 200),
+        Weapon.new(:axe, 50),
+        Weapon.new(:staff, 25)
+      ])
+    end
+  end
+end

data/spec/battle_royal/weapon_chest_spec.rb

@@ -0,0 +1,46 @@
+require 'battle_royal/weapon_chest'
+module BattleRoyal
+  describe Weapon do
+    before do
+      @weapon = Weapon.new(:axe, 50)
+    end
+
+    it 'has a name attribute' do
+      expect(@weapon.name).to eq(:axe)
+    end
+
+    it 'has a points attribute' do
+      expect(@weapon.points).to eq(50)
+    end
+  end
+
+  describe WeaponChest do
+    it 'has six weapons' do
+      expect(WeaponChest::WEAPONS.size).to eq(6)
+    end
+
+    it 'has a throwing_star worth 5 points' do
+      expect(WeaponChest::WEAPONS[0]).to eq (Weapon.new(:throwing_star, 5))
+    end
+
+    it 'has a staff worth 25 points' do
+      expect(WeaponChest::WEAPONS[1]).to eq (Weapon.new(:staff, 25))
+    end
+
+    it 'has a axe worth 50 points' do
+      expect(WeaponChest::WEAPONS[2]).to eq (Weapon.new(:axe, 50))
+    end
+
+    it 'has a mace worth 100 points' do
+      expect(WeaponChest::WEAPONS[3]).to eq (Weapon.new(:mace, 100))
+    end
+
+    it 'has a katana worth 200 points' do
+      expect(WeaponChest::WEAPONS[4]).to eq (Weapon.new(:katana, 200))
+    end
+
+    it 'has a sabre worth 400 points' do
+      expect(WeaponChest::WEAPONS[5]).to eq (Weapon.new(:sabre, 400))
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: battle_royal
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- "@shanebarringer"
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  ## battle royal
+  A Mortal Kombat influenced battle royal gem
+
+  ### To Use
+  run `gem install battle_royal`
+
+  In your terminal simply run `$ battle`
+
+  ### Notes
+
+  Currently, the game allows for users to input a certain number of rounds. The battle will run until there is only 1 player standing.
+  I recommend that you run the game for at least 10 - 100 rounds
+
+
+  ### To Contribute
+  1. Fork
+  2. Clone
+  3. Create a New Branch
+  4. Submit a Pull Request
+email: shane.barringer@outlook.com
+executables:
+- battle
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/battle
+- bin/csv/favorite_players.csv
+- bin/csv/players.csv
+- lib/battle_royal/advantaged_player.rb
+- lib/battle_royal/game.rb
+- lib/battle_royal/lame_player.rb
+- lib/battle_royal/playable.rb
+- lib/battle_royal/player.rb
+- lib/battle_royal/roll.rb
+- lib/battle_royal/weapon_chest.rb
+- spec/battle_royal/advantaged_player_spec.rb
+- spec/battle_royal/game_spec.rb
+- spec/battle_royal/lame_player_spec.rb
+- spec/battle_royal/player_spec.rb
+- spec/battle_royal/weapon_chest_spec.rb
+homepage: https://github.com/shanebarringer/battle_royal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: A Mortal Kombat influenced Battle Royal
+test_files:
+- spec/battle_royal/advantaged_player_spec.rb
+- spec/battle_royal/game_spec.rb
+- spec/battle_royal/lame_player_spec.rb
+- spec/battle_royal/player_spec.rb
+- spec/battle_royal/weapon_chest_spec.rb