poor-pokemon-cli 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 71a2535678f62aa37ce2ea61459c07bc293c79b9
+  data.tar.gz: 98be132e33af240a9ed13348841e467909b40055
+SHA512:
+  metadata.gz: a4ad6f238655a8a9d04d41a7e881e715191bf0e7c945f999d263a57eca5c4a76dbd7c6cfc96dc58bd24c0bce620878ea666f55b86ebfbf1fe4a0dd7241e2c901
+  data.tar.gz: 3438f2ae091c97b176b0b727aadc4a40fecf7b03c30d7f799e944c63bfe728c69e86bf80493c4a17019902a544e3f3b676cbfeb11ee6b6f947f3f157b868d215

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "examples/now-playing-cli-gem"]
+	path = examples/now-playing-cli-gem
+	url = git@github.com:learn-co-curriculum/now-playing-cli-gem.git

data/.learn

@@ -0,0 +1,8 @@
+tags:
+  - cli
+  - gem
+  - oo
+languages:
+  - ruby
+resources:
+live_assessment: true

data/CONTRIBUTING.md

@@ -0,0 +1,37 @@
+# Contributing to Learn.co Curriculum
+
+We're really exited that you're about to contribute to the [open curriculum](https://learn.co/content-license) on [Learn.co](https://learn.co). If this is your first time contributing, please continue reading to learn how to make the most meaningful and useful impact possible.
+
+## Raising an Issue to Encourage a Contribution
+
+If you notice a problem with the curriculum that you believe needs improvement
+but you're unable to make the change yourself, you should raise a Github issue
+containing a clear description of the problem. Include relevant snippets of
+the content and/or screenshots if applicable. Curriculum owners regularly review
+issue lists and your issue will be prioritized and addressed as appropriate.
+
+## Submitting a Pull Request to Suggest an Improvement
+
+If you see an opportunity for improvement and can make the change yourself go
+ahead and use a typical git workflow to make it happen:
+
+* Fork this curriculum repository
+* Make the change on your fork, with descriptive commits in the standard format
+* Open a Pull Request against this repo
+
+A curriculum owner will review your change and approve or comment on it in due
+course.
+
+# Why Contribute?
+
+Curriculum on Learn is publicly and freely available under Learn's
+[Educational Content License](https://learn.co/content-license). By
+embracing an open-source contribution model, our goal is for the curriculum
+on Learn to become, in time, the best educational content the world has
+ever seen.
+
+We need help from the community of Learners to maintain and improve the
+educational content. Everything from fixing typos, to correcting
+out-dated information, to improving exposition, to adding better examples,
+to fixing tests—all contributions to making the curriculum more effective are
+welcome.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specified gem's dependencies in poor-pokemon-cli-gem.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,7 @@
+#Learn.co Educational Content License
+
+Copyright (c) 2015 Flatiron School, Inc
+
+The Flatiron School, Inc. owns this Educational Content. However, the Flatiron School supports the development and availability of educational materials in the public domain. Therefore, the Flatiron School grants Users of the Flatiron Educational Content set forth in this repository certain rights to reuse, build upon and share such Educational Content subject to the terms of the Educational Content License set forth [here](http://learn.co/content-license) (http://learn.co/content-license). You must read carefully the terms and conditions contained in the Educational Content License as such terms govern access to and use of the Educational Content.  
+
+Flatiron School is willing to allow you access to and use of the Educational Content only on the condition that you accept all of the terms and conditions contained in the Educational Content License set forth [here](http://learn.co/content-license) (http://learn.co/content-license).  By accessing and/or using the Educational Content, you are agreeing to all of the terms and conditions contained in the Educational Content License.  If you do not agree to any or all of the terms of the Educational Content License, you are prohibited from accessing, reviewing or using in any way the Educational Content.

data/README.md

@@ -0,0 +1,20 @@
+# Poor-Pokemon-CLI-Gem
+###Poorly Designed Pokemon Remake (PDPR)!
+
+## Overview
+In this simple CLI gem game, the player selects whatever pokemon they want from their pokedex to be added to their roster of 6, and then battles against an opponent, "Poorly Designed Boss".
+
+The pokedex is constructed from this website (http://pokedream.com/pokedex/pokemon?display=gen1) and parsed using the gem Nokogiri.
+
+
+## Installation
+You can install this gem via `gem install poor-pokemon-cli`. The `poor-pokemon` CLI will be installed and you can run `poor-pokemon` to start playing the game right in your command line.
+
+## Usage
+Run: `poor-pokemon` after installing the gem.
+
+## Contributing
+Bug reports and pull requests are welcome on GitHub at https://github.com/mahdiASC/cli-data-gem-assessment-v-000. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/poor-pokemon

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/poor-pokemon"
+PoorPokemon::CLI.new.call

data/config/environment.rb

@@ -0,0 +1,12 @@
+require 'open-uri'
+require 'nokogiri'
+require 'pry'
+
+require_relative "../lib/poor-pokemon/basePlayer"
+require_relative "../lib/poor-pokemon/pokedexPokemon"
+require_relative "../lib/poor-pokemon/pokedex"
+require_relative "../lib/poor-pokemon/pokemon"
+require_relative "../lib/poor-pokemon/player"
+require_relative "../lib/poor-pokemon/enemy"
+require_relative "../lib/poor-pokemon/move"
+require_relative "../lib/poor-pokemon/cli"

data/lib/poor-pokemon.rb

@@ -0,0 +1,4 @@
+#Not sure what this module is for, but its everywhere -.-
+module PoorPokemon
+end
+require_relative '../config/environment'

data/lib/poor-pokemon/basePlayer.rb

@@ -0,0 +1,14 @@
+class PoorPokemon::BasePlayer
+    attr_accessor :roster, :currentPokemon
+
+    def allDead?
+        # returns true if no more pokemon left to play
+        !@roster.any?{|pokemon| pokemon.alive?}
+    end
+    
+    def changeCurrent(number)
+        #changes currentPokemon to the pokemon in roster under "number" index
+        @currentPokemon = @roster[number]
+    end
+
+end

data/lib/poor-pokemon/cli.rb

@@ -0,0 +1,420 @@
+class PoorPokemon::CLI
+  attr_accessor :player, :enemy, :pokedex, :difficulty
+
+  def initialize
+    @player = PoorPokemon::Player.new()
+    @pokedex = PoorPokemon::Pokedex.new()
+  end
+
+  def call
+    intro
+    difficulty
+    pokedexSelection
+    beginFight
+    declareWinner
+    restart
+  end
+  
+  def intro
+    puts 'Welcome to Poorly Designed Pokemon Remake (PDPR)!'
+    puts 'I\'ve scraped Pokemon and their stats from a website and created a pokedex.'
+    puts 'You\'ll battle \'Poorly Designed Boss\', who has the 6 best pokemon with perfect stats!'
+    puts 'To battle him, you\'ll select 6 pokemon from the pokedex to add to your roster'
+    puts 'Then you\'ll take turns attacking his pokemon with yours.'
+    puts 'Unfortunately, \'Poorly Designed Boss\' has sabatoged your pokemon by giving them random attacks and imperfect stats!'
+    puts 'Can you still defeat him, despite being at a disadvantage!?'
+    puts 'Good luck, and have fun!'
+  end
+  
+  def difficulty
+    #Sets difficulty of Enemy AI
+    userInput = ""
+    choices = ['e','h','easy','hard']
+    until choices.include?(userInput) do
+      puts "Select Difficulty: (e)asy (h)ard"
+      userInput = gets.strip.downcase
+    end
+    @difficulty = userInput
+    if userInput == "e" || userInput == "easy"
+      @enemy = PoorPokemon::Enemy.new(@pokedex.randSix(true))
+      fillMoves(@enemy, "easy")
+    elsif userInput == "h" || userInput == "hard"
+      @enemy = PoorPokemon::Enemy.new(@pokedex.bestSix(true))
+      fillMoves(@enemy, "hard")
+    end
+  end
+
+  def fillMoves(char, diff=nil)
+    #fills char's pokemon roster with appropriate moves
+    #moves are different for enemy
+    if char.is_a?(PoorPokemon::Player)
+      char.roster.each{|pokemon|
+        output = []
+        output.push(PoorPokemon::Move.new("Normal Attack",randAtt(45),"Normal",30))
+        output.push(PoorPokemon::Move.new("Big Normal Attack",randAtt(110),"Normal",10))
+        output.push(PoorPokemon::Move.new("Special Attack",randAtt(70),randType,20))
+        output.push(PoorPokemon::Move.new("Big Special Attack",randAtt(100),randType,5))
+        pokemon.moves = output
+      }
+    else
+      #Enemy player
+      if diff == "easy"
+        char.roster.each{|pokemon|
+          output = []
+          output.push(PoorPokemon::Move.new("Normal Attack",randAtt(45),"Normal",30))
+          output.push(PoorPokemon::Move.new("Big Normal Attack",randAtt(110),"Normal",10))
+          output.push(PoorPokemon::Move.new("Special Attack",randAtt(70),randType,20))
+          output.push(PoorPokemon::Move.new("Big Special Attack",randAtt(100),randType,5))
+          pokemon.moves = output
+        }
+      elsif diff == "hard"
+        char.roster.each{|pokemon|
+          output=[]
+          output.push(PoorPokemon::Move.new("Normal Attack",40,"Normal",30))
+          output.push(PoorPokemon::Move.new("Big Normal Attack",100,"Normal",10))
+          output.push(PoorPokemon::Move.new("Special Attack",65,pokemon.type1,20))
+          output.push(PoorPokemon::Move.new("Big Special Attack",90,pokemon.type1,5))
+          pokemon.moves = output
+        }
+      end
+    end
+
+  end
+
+  def randType
+      ["Bug","Dragon","Ice","Fighting","Fire","Flying","Grass","Ghost","Ground","Electric","Normal","Poison","Psychic","Rock","Water"].sample
+  end
+
+  def randAtt(num)
+      var = (num * 0.1).round
+      rand(var)+num-var
+  end
+
+  def displayPokemon(pokeGroup)
+    #pokeGroup is an array of PokedexPokemon
+    #must have at least 1 item in array
+    #Displays the group for the user
+    maxNameLength = pokeGroup.sort{|a,b| a.name.length<=>b.name.length}.last.name.length+5
+
+    pokeGroup.each_index{|i| 
+      name = "#{i+1}. #{pokeGroup[i].name.capitalize}"
+      until name.length >= maxNameLength do
+        name = name + " "
+      end
+      types = pokeGroup[i].type2 != "" ? pokeGroup[i].type1.capitalize + "+" + pokeGroup[i].type2.capitalize : pokeGroup[i].type1.capitalize
+      puts "#{name} TYPE:#{types} HP:#{pokeGroup[i].hp} ATT:#{pokeGroup[i].att} DEF:#{pokeGroup[i].def} SPD:#{pokeGroup[i].spd} SP-ATT:#{pokeGroup[i].spAtt} SP-DEF:#{pokeGroup[i].spDef}"
+    }
+  end  
+
+  def pokedexSelection
+    #player will begin selecting desired pokemon from pokedex
+    #Ends when player has full roster
+    until @player.roster.length>=6 do
+      showPlayerRoster
+      playerSelection
+    end
+    showPlayerRoster
+    fillMoves(@player)
+  end
+  
+  def showPlayerRoster
+    puts "YOUR ROSTER:"
+    if @player.roster.length>0
+      @player.roster.each_index{|i|
+        puts "#{i+1}. #{@player.roster[i].name.capitalize}"
+      }
+    else
+      puts "{There are no pokemon in your roster}"
+    end
+    sepLine
+  end
+
+  def playerSelection
+    userInput = ""
+    until ["1","2"].include?(userInput) do
+      puts "Select a pokemon from the Pokedex, to add to your roster (#{6-@player.roster.length} left to pick)"
+      puts "Options: (1)List all pokemon (2)Search by name"
+      userInput = gets.strip
+      case userInput
+      when "1"
+        searchResults = @pokedex.pokeList #full list of pokemon
+      when "2"
+        searchResults = []
+        until searchResults.length>0 do
+          puts 'Type in a name or partial name to search: '
+          searchInput = gets.strip
+          searchResults = @pokedex.searchName(searchInput)
+          if searchResults.length<1
+            puts "{No results found. Try again.}"
+          end
+        end
+      else
+        invalid
+      end
+    end  
+    sepLine
+    # Either list all pokemon, or allow for search by name
+    displayPokemon(searchResults)
+    sepLine
+    #User selects pokemon
+    validSelection = ""
+    until (1..searchResults.length).map{|x| x.to_s}.include?(validSelection) do
+      puts "Select the number of the pokemon to add to your roster"
+      validSelection=gets.strip
+    end
+    sepLine
+    @player.add(searchResults[validSelection.to_i-1].clone)
+  end
+
+  def sepLine
+    puts "____________________"
+  end
+
+  def invalid
+    puts "{Invalid selection. Try again.}"
+  end
+
+  def beginFight
+    puts "\'Poorly Designed Boss\' wants to battle!"
+    displayBothRosters
+    playerSwitch
+    until @player.allDead? || @enemy.allDead? do
+      turnOrder
+    end
+  end
+  
+  def displayBothRosters
+    maxLength = @player.roster.sort{|a,b| a.name.length<=>b.name.length}.last.name.length+2
+    title = "You"
+    until title.length >= maxLength do
+        title = " " + title
+    end
+    puts title + " || Enemy"
+    sepLine
+    @player.roster.each_index{|i|
+      text = @player.roster[i].name.upcase
+      until text.length >= maxLength do
+        text = " " + text
+      end
+      typeText = @enemy.roster[i].type2!="" ? " (#{@enemy.roster[i].type1.capitalize}+#{@enemy.roster[i].type2.capitalize})" : " (#{@enemy.roster[i].type1.capitalize})"
+      text = text + " || " + @enemy.roster[i].name.upcase + typeText
+      puts text
+    }
+
+  end
+
+  def declareWinner
+    if @player.allDead?
+      puts "You lost!"
+    else
+      puts "You won!"
+    end
+  end
+
+  def turnOrder
+    #decides turn order based on each player's current pokemon's speed
+    #in event of tie, random
+    if @player.currentPokemon.spd == @enemy.currentPokemon.spd
+      if rand()>0.5
+        playerTurn
+        if @enemy.currentPokemon.alive?
+          enemyTurn
+        end
+      else
+        enemyTurn
+        if @player.currentPokemon.alive?
+          playerTurn
+        end
+      end
+    elsif @player.currentPokemon.spd>@enemy.currentPokemon.spd
+      playerTurn
+      if @enemy.currentPokemon.alive?
+        enemyTurn
+      end
+    elsif @player.currentPokemon.spd<@enemy.currentPokemon.spd
+      enemyTurn
+      if @player.currentPokemon.alive?
+        playerTurn
+      end
+    end
+
+    #switch if any dead and player still has usable pokemon
+    if !@player.currentPokemon.alive?
+      puts "Your #{@player.currentPokemon.name.upcase} fainted!"
+      if !@player.allDead?
+        playerSwitch
+      end
+    end
+    if !@enemy.currentPokemon.alive?
+      puts "Enemy #{@enemy.currentPokemon.name.upcase} fainted!"
+      if !@enemy.allDead?
+        @enemy.switch
+        puts "Enemy sent out #{@enemy.currentPokemon.name.upcase}!"
+      end
+    end
+
+    if !gameWon?
+      currentStatus
+    end
+  end
+
+  def playerTurn
+    puts "###Your Turn###"
+    typeText = @player.currentPokemon.type2 != "" ? "#{@player.currentPokemon.type1}+#{@player.currentPokemon.type2}" : "#{@player.currentPokemon.type1}"
+    puts "Current Pokemon: #{@player.currentPokemon.name.upcase} HP:#{@player.currentPokemon.hp} TYPE: #{typeText.upcase}"
+    typeText = @enemy.currentPokemon.type2 != "" ? "#{@enemy.currentPokemon.type1}+#{@enemy.currentPokemon.type2}" : "#{@enemy.currentPokemon.type1}"
+    puts "Enemy Pokemon: #{@enemy.currentPokemon.name.upcase} HP:#{@enemy.currentPokemon.hp} TYPE: #{typeText.upcase}"
+    sepLine
+    puts "What would you like to do? (a)ttack (s)witch"
+    userInput = ""
+    choices = ["a","attack","s","switch"]
+    until choices.include?(userInput) do
+      userInput = gets.strip.downcase
+      if (userInput == "s" || userInput == "switch")
+        playerSwitch
+      elsif(userInput == "a" || userInput == "attack")
+        playerAttacks(@enemy.currentPokemon)
+      else
+        invalid
+      end
+    end
+    sepLine
+  end
+
+  def playerSwitch
+    #Player switches current pokemon from roster
+    sepLine
+    if @player.currentPokemon
+      puts "Select Pokemon from your roster to switch to:"
+    else
+      puts "Select Pokemon from your roster to start with:"
+    end
+    userInput = "0"
+    until @player.valids.include?(@player.roster[userInput.to_i-1]) && userInput != "0" do
+      showPlayerSwitchRoster
+      userInput = gets.strip
+      if !@player.valids.include?(@player.roster[userInput.to_i-1])
+        invalid
+      end
+    end
+    if @player.currentPokemon
+      puts "#{@player.currentPokemon.name.upcase} returns!"
+    end
+    @player.changeCurrent(userInput.to_i-1)
+    puts "#{@player.currentPokemon.name.upcase} enters the battle!"
+  end
+
+  def showPlayerSwitchRoster
+    maxLength = @player.roster.sort{|a,b| a.name.length<=>b.name.length}.last.name.length+5
+
+    @player.roster.each_index{|i|
+      health = @player.roster[i].alive? ? @player.roster[i].hp.to_s + " HP" : "FAINTED!"
+      text = "#{i+1}. #{@player.roster[i].name.upcase}"
+      until text.length >= maxLength do
+        text = text + " "
+      end
+      if health !="FAINTED!"
+        puts "#{text}| STATUS: #{health} spAtt1:#{@player.roster[i].moves[2].name.match(/(?<=\().*(?=\))/)[0].upcase}/PP #{@player.roster[i].moves[2].pp}  spAtt2:#{@player.roster[i].moves[3].name.match(/(?<=\().*(?=\))/)[0].upcase}/PP #{@player.roster[i].moves[3].pp}"
+      else
+        puts "#{text}| STATUS: #{health}"
+      end
+    }
+    sepLine
+  end
+
+  def playerAttacks(enemyPokemon)
+    #gives user options on what move to attack with
+    sepLine
+    if @player.currentPokemon.canAttack?
+      userInput = "0"
+      availMoves = @player.currentPokemon.usableMoves
+      until availMoves.include?(@player.currentPokemon.moves[userInput.to_i-1]) && userInput!="0" do
+        puts "Which move should #{@player.currentPokemon.name.capitalize} use?"
+        maxLength = @player.currentPokemon.moves.sort{|a,b| a.name.length<=>b.name.length}.last.name.length+5
+        @player.currentPokemon.moves.each_index{|i|
+          move = @player.currentPokemon.moves[i]
+          text = "#{i+1}. #{move.name.upcase}"
+          until text.length >= maxLength do
+            text = text + " "
+          end
+          puts "#{text} > PP: #{move.pp}"
+        }
+        userInput = gets.strip
+        if !availMoves.include?(@player.currentPokemon.moves[userInput.to_i-1]) && userInput!="0"
+          invalid
+        end
+      end
+      move = @player.currentPokemon.moves[userInput.to_i-1]
+      puts "#{@player.currentPokemon.name.upcase} used #{move.name.split(" (")[0].upcase} (#{move.type})!"
+      puts dmgText(@player.currentPokemon.attacks(enemyPokemon,move))
+    else 
+      #current pokemon is out of PP for all moves, defaults to "Struggle"
+      struggle = PoorPokemon::Move.new("Struggle",40,"Normal",99)
+      puts "#{@player.currentPokemon.name.upcase} is out of moves!"
+      puts "#{@player.currentPokemon.name.upcase} used STRUGGLE! #{struggle.type}"
+      puts dmgText(@player.currentPokemon.attacks(enemyPokemon,struggle))
+    end
+  end
+
+  def dmgText(dmgArray)
+    #depending on the number, will evaluate the effectiveness of the attack
+    #returns a string to communicate that effectiveness
+    dmg = dmgArray[0]
+    num = dmgArray[1]
+   
+    if num == 0
+      output = "No effect!"
+    elsif num == 0.5 || num == 0.25
+      output = "It's not very effective."
+    elsif num == 2
+      output = "It's super-effective!"
+    elsif num == 4
+      output = "Critical hit!" #Not a true critical hit
+    else
+      output = "It hit!"
+    end
+    output + " (#{dmg} dmg)"
+  end
+
+  def enemyTurn
+    puts "###Enemy Turn###"
+    if @enemy.currentPokemon.canAttack?
+      attackArray = @enemy.attacks(@player.currentPokemon,@difficulty)
+      puts "#{@enemy.currentPokemon.name.upcase} used #{attackArray[1].name.split(" (")[0].upcase}  (#{attackArray[1].type})!"
+      puts dmgText(attackArray[0])
+    else 
+      #current pokemon is out of PP for all moves, defaults to "Struggle"
+      struggle = PoorPokemon::Move.new("Struggle",40,"Normal",99)
+      attackArray = @enemy.attacks(@player.currentPokemon, @difficulty, struggle)
+      puts "Enemy #{@enemy.currentPokemon.name.upcase} is out of moves!"
+      puts "Enemy #{@enemy.currentPokemon.name.upcase} used STRUGGLE #{struggle.type}!"
+      puts dmgText(attackArray[0])
+    end
+    sepLine
+  end
+
+  def currentStatus
+    #prints current status for both sides
+    puts "Your #{@player.currentPokemon.name.capitalize} has #{@player.currentPokemon.hp} HP"
+    puts "Enemy #{@enemy.currentPokemon.name.capitalize} has #{@enemy.currentPokemon.hp} HP"
+    sepLine
+  end
+
+  def gameWon?
+    @enemy.allDead? || @player.allDead?
+  end
+
+  def restart
+    sepLine
+    puts "Would you like to play again? (y)es (n)o"
+    choices = ["y","n","yes","no"]
+    userInput = ''
+    until choices.include?(userInput) do
+      userInput = gets.strip.downcase
+    end
+
+    if(userInput == "y" || userInput == "yes")
+      call
+    end
+  end
+end

data/lib/poor-pokemon/enemy.rb

@@ -0,0 +1,27 @@
+class PoorPokemon::Enemy < PoorPokemon::BasePlayer
+    def initialize(pokeGroup)
+        @roster = pokeGroup
+        @currentPokemon = @roster[0]
+    end
+
+    def switch
+        #switches current pokemon (should be dead) for another valid pokemon
+        @currentPokemon = @roster.select{|pokemon|pokemon.alive?}.sample
+    end
+
+    def attacks(oppPokemon, diff, move=nil)
+        #determines how enemy AI attacks depending on difficulty
+        if move
+            dmg = @currentPokemon.attacks(oppPokemon, move)
+        else
+            if diff == "easy" || diff =='e'
+                move = @currentPokemon.usableMoves.sample
+                dmg = @currentPokemon.attacks(oppPokemon, move)
+            elsif diff == "hard" || diff =="h"
+                move = @currentPokemon.usableMoves.sort{|moveA,moveB| moveA.dmg<=>moveB.dmg}.last
+                dmg = @currentPokemon.attacks(oppPokemon, move)
+            end
+        end
+        [dmg, move]
+    end
+end

data/lib/poor-pokemon/move.rb

@@ -0,0 +1,15 @@
+class PoorPokemon::Move
+  attr_accessor :name, :dmg, :type, :pp
+
+  def initialize (name, dmg, type, pp)
+    @name = "#{name} (#{type})"
+    @dmg = dmg
+    @type = type
+    @pp = pp
+  end
+
+  def usable?
+    #returns true if move has enough PP to be used
+    @pp>0
+  end
+end

data/lib/poor-pokemon/player.rb

@@ -0,0 +1,14 @@
+class PoorPokemon::Player < PoorPokemon::BasePlayer
+    def initialize
+        @roster = []
+    end
+
+    def add(pokemon)
+        @roster.push(pokemon)
+    end
+
+    def valids
+        #returns array of living pokemon
+        @roster.select{|pokemon|pokemon.alive?}
+    end
+end

data/lib/poor-pokemon/pokedex.rb

@@ -0,0 +1,40 @@
+class PoorPokemon::Pokedex
+  attr_accessor :pokeList
+  def initialize
+    # Pokemon database
+    # http://pokedream.com/pokedex/pokemon?display=gen1
+    pokemonDoc = Nokogiri::HTML(open("http://pokedream.com/pokedex/pokemon?display=gen1"))
+    @pokeList = pokemonDoc.css(".UILinkedTableRow").map{ |row|
+      rowData = row.children().map{ |col|
+        if col.attribute("class")
+          col.attribute("class").value
+        else
+          col.text()
+        end
+      }.reject{|val| val == "\n" || val == "---"}
+      rowData
+    }.map{|row|
+      PoorPokemon::PokedexPokemon.new(row)
+    }
+  end
+
+  def bestSix(flag=false)
+    #flag is for enemy to have perfect stats
+    @pokeList.sort{|pokemonA,pokemonB| pokemonB.totalStats <=> pokemonA.totalStats}.take(6).map{|pokemon|pokemon.clone(flag)}
+  end
+
+  def randSix(flag=false)
+    #flag is for enemy to have perfect stats
+    randArray = []
+    6.times do
+      randArray.push(@pokeList.sample.clone(flag))
+    end
+    randArray
+  end
+
+  def searchName(word)
+    @pokeList.select{|pokemon| pokemon.name[word]} 
+  end
+
+end
+

data/lib/poor-pokemon/pokedexPokemon.rb

@@ -0,0 +1,14 @@
+class PoorPokemon::PokedexPokemon
+  attr_accessor :name, :num, :type1, :type2, :hp, :att, :def, :spAtt, :spDef, :spd, :totalStats
+
+  def initialize(arr)
+    @name, @num, @type1,  @type2, @hp, @att, @def, @spAtt, @spDef, @spd, @totalStats = arr
+  end
+
+  def clone (flag=false)
+    # creates a copy of this pokedexPokemon object as a pokemon object
+    # moves is an array of moves
+    #flag is for enemy to have perfect stats
+    return PoorPokemon::Pokemon.new([@name, @type1, @type2, @hp.to_i, @att.to_i, @def.to_i, @spAtt.to_i, @spDef.to_i, @spd.to_i], flag)
+  end
+end

data/lib/poor-pokemon/pokemon.rb

@@ -0,0 +1,190 @@
+class PoorPokemon::Pokemon
+  attr_accessor :name, :type1, :type2, :hp, :att, :def, :spAtt, :spDef, :spd, :moves
+
+
+  def initialize(arr, flag=false)
+    #flag is for enemy to have perfect stats
+    @name, @type1, @type2, @hp, @att, @def, @spAtt, @spDef, @spd = arr
+
+    #Determines proper stats
+    #https://www.dragonflycave.com/mechanics/stats
+    #Individual stats (0-15)
+    atkIV = flag ? 15: rand(15)
+    @att += atkIV
+    @att = @att*2+68
+    
+
+    defIV = flag ? 15:rand(15)
+    @def += defIV
+    @def = @def*2+68
+
+    spdIV = flag ? 15:rand(15)
+    @spd += spdIV
+    @spd = @spd*2+68
+
+    spIV = flag ? 15:rand(15)
+    @spAtt += spIV
+    @spAtt = @spAtt*2+68
+    @spDef += spIV
+    @spDef = @spDef*2+68
+
+    #how HP and IV are connected
+    if atkIV%2==1
+      @hp +=  8
+    end
+    
+    if defIV%2==1
+      @hp +=  4
+    end
+    
+    if spdIV%2==1
+      @hp +=  2
+    end
+    
+    if spIV%2==1
+      @hp +=  1
+    end
+    @hp = @hp*2+110
+
+    @moves = []
+  end
+
+  def alive?
+    @hp > 0
+  end
+
+  def attacks(oppPokemon, move)
+    #dmg calculations
+    attackStat = ["normal", "fighting", "flying", "poison", "ground", "rock", "bug", "ghost"].include?(move.type) ? @att : @spAtt
+    attackPower = move.dmg
+    defenseStat = ["normal", "fighting", "flying", "poison", "ground", "rock", "bug", "ghost"].include?(move.type) ? oppPokemon.def : oppPokemon.spDef
+    randNum = rand(255-217)+217
+    stab = move.type == @type1 || move.type == @type2 ? 1.5 : 1
+    weakResist = calcWeakResist(oppPokemon,move)
+
+    #dmg equation
+    damageTotal = (((((42 * attackStat.to_f * (attackPower.to_f/defenseStat.to_f))/50)+2)*stab.to_f*weakResist.to_f)*randNum.to_f/255).floor
+
+    #applying dmg
+    move.pp -= 1
+    oppPokemon.hp -= damageTotal
+    if oppPokemon.hp < 0
+      oppPokemon.hp = 0 #just in case HP checked
+    end
+    [damageTotal,weakResist]
+  end
+
+  def calcWeakResist(oppPokemon,move, typeInput=nil)
+    #returns multiplier for attack effectiveness
+    #0.25, 0.5, 1, 2, or 4
+    # http://unrealitymag.com/wp-content/uploads/2014/11/rby-rules.jpg
+    type = (typeInput || oppPokemon.type1).downcase
+    output = 1; #number returned as modifier
+    case move.type.downcase
+    when 'normal'
+      if ['ghost'].include?(type)
+        output *= 0
+      end
+    when 'bug'
+      if ['fire','flying',"rock"].include?(type)
+        output*=0.5
+      elsif ['grass','poison',"psychic"].include?(type)
+        output*=2
+      end
+    when 'dragon'
+      #No effectiveness
+    when 'ice'
+      if ['ice','water'].include?(type)
+        output*=0.5
+      elsif ['dragon','flying','grass','ground'].include?(type)
+        output*=2
+      end
+    when 'fighting'
+      if ['flying','psychic'].include?(type)
+        output*=0.5
+      elsif ['ice','normal','rock'].include?(type)
+        output*=2
+      elsif ['ghost'].include?(type)
+        output*=0
+      end
+    when 'fire'
+      if ['rock','water'].include?(type)
+        output*=0.5
+      elsif ['bug','grass','ice'].include?(type)
+        output*=2
+      end
+    when 'flying'
+      if ['electric','rock'].include?(type)
+        output*=0.5
+      elsif ['bug','fighting',"grass"].include?(type)
+        output*=2
+      end
+    when 'grass'
+      if ['bug','fire','flying','grass','poison'].include?(type)
+        output*=0.5
+      elsif ['ground','rock','water'].include?(type)
+        output*=2
+      end
+    when 'ghost'
+      if ['normal','psychic'].include?(type)
+        output*=0
+      end
+    when 'ground'
+      if ['grass'].include?(type)
+        output*=0.5
+      elsif ['electric','fire','poison','rock'].include?(type)
+        output*=2
+      elsif ['flying'].include?(type)
+        output*=0
+      end
+    when 'electric'
+      if ['electric','grass'].include?(type)
+        output*=0.5
+      elsif ['flying','water'].include?(type)
+        output*=2
+      elsif ['ground'].include?(type)
+        output*=0
+      end
+    when 'poison'
+      if ['ground','poison','rock'].include?(type)
+        output*=0.5
+      elsif ['bug','grass'].include?(type)
+        output*=2
+      end
+    when 'psychic'
+      if ['psychic'].include?(type)
+        output*=0.5
+      elsif ['fighting','poison'].include?(type)
+        output*=2
+      end
+    when 'rock'
+      if ['fighting','rock'].include?(type)
+      elsif ['bug','fire','flying','ice'].include?(type)
+      end
+    when 'water'
+      if ['grass','ice'].include?(type)
+        output*=0.5
+      elsif ['fire','ground','rock'].include?(type)
+        output*=2
+      end
+    else
+      puts "SOMETHING WENT WRONG WITH TYPE DMG"
+      puts "MoveType: #{move.type.downcase} Type: #{type.downcase}"
+    end
+
+    if(typeInput.nil? && oppPokemon.type2 !="")
+      output *= calcWeakResist(oppPokemon,move, oppPokemon.type2)
+    end
+    output
+  end
+
+  def canAttack?
+    #returns true if pokemon has enough PP to attack
+    @moves.any?{|move| move.usable?}
+  end
+
+  def usableMoves
+    #returns array of usable moves
+    @moves.select{|move| move.usable?}
+  end
+end

data/lib/poor-pokemon/version.rb

@@ -0,0 +1,3 @@
+module PoorPokemon
+    VERSION = "1.0.0"
+end

data/poor-pokemon-cli-gem.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "poor-pokemon/version"
+
+Gem::Specification.new do |spec|
+  spec.authors       = ["Mahdi Shadkam-Farrokhi"]
+  spec.email         = ["mahdi@allstarcode.org"]
+  spec.description   = "A simple pokemon CLI"
+  spec.summary       = "In this simple CLI gem game, the player selects whatever pokemon they want from their pokedex to be added to their roster of 6, and then battles against an opponent, \"Poorly Designed Boss\"."
+  spec.version       = PoorPokemon::VERSION
+  spec.homepage      = 'http://rubygems.org/gems/poor-pokemon'
+  spec.date          = Time.now.utc.strftime("%Y-%m-%d")
+  spec.files         = `git ls-files`.split($\)
+  spec.executables   = ["poor-pokemon"]
+  spec.name          = "poor-pokemon-cli"
+  spec.require_paths = ["lib", "lib/poor-pokemon"]
+  spec.license       = "MIT"
+
+  spec.add_development_dependency "pry"
+  
+  spec.add_dependency "nokogiri"
+end

data/spec.md

@@ -0,0 +1,9 @@
+# Specifications for the CLI Assessment
+
+Specs:
+- [x] Have a CLI for interfacing with the application
+    -I've created a working Ruby CLI for playing pokemon.
+- [x] Pull data from an external source
+    -The application properly pulls data from an external website using the 'open-uri' gem.
+- [x] Implement both list and detail views
+    -The application uses a 'pokedex' to allow users to interact with a list of pokemon (both from a full list or by searching). The users select their pokemon and store them in a roster, from which they can battle an opponent.

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: poor-pokemon-cli
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mahdi Shadkam-Farrokhi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple pokemon CLI
+email:
+- mahdi@allstarcode.org
+executables:
+- poor-pokemon
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitmodules"
+- ".learn"
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.md
+- README.md
+- bin/poor-pokemon
+- config/environment.rb
+- lib/poor-pokemon.rb
+- lib/poor-pokemon/basePlayer.rb
+- lib/poor-pokemon/cli.rb
+- lib/poor-pokemon/enemy.rb
+- lib/poor-pokemon/move.rb
+- lib/poor-pokemon/player.rb
+- lib/poor-pokemon/pokedex.rb
+- lib/poor-pokemon/pokedexPokemon.rb
+- lib/poor-pokemon/pokemon.rb
+- lib/poor-pokemon/version.rb
+- poor-pokemon-cli-gem.gemspec
+- spec.md
+homepage: http://rubygems.org/gems/poor-pokemon
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/poor-pokemon
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: In this simple CLI gem game, the player selects whatever pokemon they want
+  from their pokedex to be added to their roster of 6, and then battles against an
+  opponent, "Poorly Designed Boss".
+test_files: []