MeChallenge 1.0.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2008-12-18
+
+* 1 First Cut
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/me_challenge
+lib/me_challenge.rb
+lib/middle_earth_challenge_simulator.rb
+test/test_me_challenge.rb
+test/test_middle_earth_challenge_simulator.rb

data/README.txt

@@ -0,0 +1,55 @@
+= MeChallenge
+
+* http://rubyforge.org/projects/uwruby
+* http://uwruby.rubyforge.org/MeChallenge
+
+== DESCRIPTION:
+
+This command line utility simulates n number of personal challenge combats
+in the PBM game Ware in Middle Earth.
+
+== FEATURES/PROBLEMS:
+
+* Specify challenge rank 
+* Specify health
+* Specify number of simulations
+
+== SYNOPSIS:
+
+USAGE:
+        me_challenge rank1 health1 rank2 health2 rounds
+EXAMPLE:
+        me_challenge 50 100 30 100 10000
+
+== REQUIREMENTS:
+
+* Ruby 1.8.6
+
+== INSTALL:
+
+* sudo gem install MeChallenge
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Chesley Coughlin
+
+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/Rakefile

@@ -0,0 +1,13 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/me_challenge.rb'
+
+Hoe.new('MeChallenge', MeChallenge::VERSION) do |p|
+  p.rubyforge_name = 'uwruby' # if different than lowercase project name
+  p.developer('Chesley Coughlin', 'chesley_coughlin@yahoo.com')
+  
+end
+
+# vim: syntax=Ruby

data/bin/me_challenge

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -w
+require 'rubygems'
+require 'me_challenge'
+
+MeChallenge.run(ARGV)

data/lib/me_challenge.rb

@@ -0,0 +1,13 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'middle_earth_challenge_simulator'
+
+class MeChallenge
+  VERSION = '1.0.0'
+  
+  def self.run(args)
+    MiddleEarthChallengeSimulator.run(args)
+  end
+end
+
+MeChallenge.run(ARGV) if ($0 == __FILE__ || false)

data/lib/middle_earth_challenge_simulator.rb

@@ -0,0 +1,187 @@
+# 
+# Middle Earth Challenge Simulator
+# Copyright (C) 2008, Chesley Coughlin
+# WEEK 8 Homework
+ 
+class Character
+  include Comparable
+  
+  MAX_HEALTH = 100
+  attr_accessor :challenge_rank
+  attr_reader :name, :health
+  
+  def initialize (n, c, h)
+    @name = n
+    @challenge_rank = c
+    @health = h
+  end
+
+  def health=(h)
+    raise ArgumentError, "Health #{h} greater than max health #{MAX_HEALTH}" if (h > MAX_HEALTH)
+    @health = h
+  end
+  
+  def to_s
+    "Character {name: #{self.name} challenge_rank: #{self.challenge_rank} " \
+      "health: #{self.health}}"
+  end
+  
+  def <=> c
+    return self.challenge_rank <=> c.challenge_rank
+  end  
+end
+
+class Attack 
+  include Comparable
+  CRITICAL_MISS = 5
+  CRITICAL_HIT = 96
+
+  attr_reader :attack_value, :critical_hit, :critical_miss, :r1, :r2, 
+    :challenge_rank
+  
+  def initialize(c, roll1 = rand(99) + 1, roll2 = rand(99)+1)
+    @challenge_rank = c
+    @r1 = roll1
+    @critical_miss = @r1 <= CRITICAL_MISS
+    @critical_hit = @r1 >= CRITICAL_HIT
+    @r2 = 0
+    @r2 = roll2 if (self.critical_hit || self.critical_miss)
+    @attack_value = @r1 + @challenge_rank
+    @attack_value = @attack_value - @r2 if self.critical_miss
+    @attack_value = @attack_value + @r2 if self.critical_hit
+  end
+  
+  def <=> a    
+    return self.attack_value <=> a.attack_value      
+  end
+  
+  def to_s
+    "Attack {attack_value: #{@attack_value} " \
+      "challenge_rank #{@challenge_rank} " \
+      "r1: #{@r1} " \
+      "critical_hit: #{@critical_hit} " \
+      "critical_miss: #{@critical_miss} " \
+      "r2: #{@r2}}"
+  end  
+end
+
+class CombatRound
+  attr_reader :attack1, :attack2, :damage, :character1, :character2
+  def initialize(a1, a2, d, c1, c2)
+    @attack1 = a1
+    @attack2 = a2
+    @damage = d
+    @character1 = c1.dup
+    @character2 = c2.dup
+  end
+end
+
+class MiddleEarthCombat
+  attr_reader :character1, :character2, :results, :victor
+  
+  def initialize (c1, c2)
+    raise ArgumentError if c1.health <= 0 || c2.health <= 0
+    @character1 = c1
+    @character2 = c2
+    @victor = nil
+    @results = []
+  end
+  
+
+  def MiddleEarthCombat.get_damage(a1, a2)   
+    #tie
+    return 0 if (a1 == a2)
+    
+    max_damage = a1.attack_value - a2.attack_value if a1 > a2
+    max_damage = a2.attack_value - a1.attack_value if a2 > a1
+    return rand(max_damage) + 1      
+  end
+
+  def do_round(a1 = Attack.new(@character1.challenge_rank), 
+      a2 = Attack.new(@character2.challenge_rank), 
+      d = MiddleEarthCombat.get_damage(a1, a2))
+
+    raise RuntimeError if @character1.health <= 0 || @character2.health <= 0
+    if a1 > a2
+      @character2.health = @character2.health - d
+    elsif a2 > a1
+      @character1.health = @character1.health - d
+    else
+      #tie
+    end            
+    
+    @results << CombatRound.new(a1, a2, d, @character1, @character2)    
+  end    
+  
+  def fight
+    until self.character1.health <= 0 || self.character2.health <= 0
+      do_round      
+    end
+    @victor = self.character1.health > 0 ? self.character1 : self.character2
+  end
+  
+  def to_s
+    result = "============================================================\n" \
+             "MiddleEarthCombat\n" \
+             "Victor: #{@victor}\n" \
+             "after #{@results.size} rounds\n" \
+             "============================================================\n" \
+             "Combat Details\n"
+    @results.each do |r|
+      result << "------------------------------------------\n"
+      result << "Damage #{r.damage}\n"
+      result << "#{r.character1} attack was #{r.attack1}\n"
+      result << "#{r.character2} attack was #{r.attack2}\n"      
+    end
+    
+  return result      
+  end
+end
+
+class MiddleEarthChallengeSimulator
+  attr_reader :character1, :character2, :character1_wins, 
+    :character2_wins, :num_rounds
+  
+  def initialize (c1, c2, rounds)
+    raise ArgumentError if c1.health <= 0 || c2.health <= 0
+    
+    @character1 = c1.dup
+    @character2 = c2.dup
+    @num_rounds = rounds    
+    @character1_wins = 0
+    @character2_wins = 0
+  end
+  
+  def simulate
+    (1..@num_rounds).each do
+      me_combat = MiddleEarthCombat.new(@character1.dup, @character2.dup)
+      me_combat.fight
+      @character1_wins += 1 if (@character1.name == me_combat.victor.name)
+      @character2_wins += 1 if (@character2.name == me_combat.victor.name)             
+      
+    end
+  end    
+  
+  def MiddleEarthChallengeSimulator.run(args)
+    unless args.size == 5
+      puts "\nUSAGE:\n\tmiddle_earth_challenge_simulator.rb rank1 health1 rank2 health2 rounds\n"
+      puts "EXAMPLE:\n\tmiddle_earth_challenge_simulator.rb 50 100 30 100 10000"
+      return -1
+    end
+    
+    c1 = Character.new("Character #1", args.shift.to_i, args.shift.to_i)
+    c2 = Character.new("Character #2", args.shift.to_i, args.shift.to_i)
+    rounds = args.shift.to_i
+    
+    puts "Simulating #{rounds} rounds of combat between #{c1} and #{c2}\n"
+    
+    mec = MiddleEarthChallengeSimulator.new(c1, c2, rounds)
+    mec.simulate
+    
+    puts "#{mec.character1} won #{mec.character1_wins}"
+    puts "#{mec.character2} won #{mec.character2_wins}"        
+    
+  end
+end
+
+MiddleEarthChallengeSimulator.run(ARGV) if ($0 == __FILE__ || false)

data/test/test_middle_earth_challenge_simulator.rb

@@ -0,0 +1,224 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'middle_earth_challenge_simulator'
+
+class TestMiddleEarthChallengeSimulator < Test::Unit::TestCase
+  def setup 
+    @c1 = Character.new("Arg the Barbarian", 30, 100)
+    @c2 = Character.new("Bob the Emmy", 15, 100)
+    @c3 = Character.new("Chester the Wounded", 15, 1)
+    @c4 = Character.new("Dorris the Dead", 30, 0)
+    @c5 = Character.new("Jason the Bold", 200, 100)
+    @a1 = Attack.new(50, 45, 46)
+    @a2 = Attack.new(50, 5, 100)
+    @a3 = Attack.new(10, 98, 5)
+  end
+   
+  def test_character_health
+    @c1.health = Character::MAX_HEALTH    
+    
+    assert_equal Character::MAX_HEALTH, @c1.health
+    assert_raise ArgumentError do
+      @c1.health = Character::MAX_HEALTH + 1
+    end
+  end  
+
+  def test_attack
+    a = Attack.new(50, 45, 46)
+    
+    assert_equal 95, a.attack_value
+    assert_equal 45, a.r1
+    assert_equal 0, a.r2
+    assert_equal 50, a.challenge_rank
+    assert_equal false, a.critical_hit
+    assert_equal false, a.critical_miss    
+  end
+  
+  def test_attack_critical_miss
+    a = Attack.new(50, 5, 100)
+
+    expected_attack_value = -45  #editor was barking about -45 in the assert_equal    
+    assert_equal expected_attack_value, a.attack_value
+    assert_equal 5, a.r1
+    assert_equal 100, a.r2
+    assert_equal 50, a.challenge_rank    
+    assert_equal false, a.critical_hit
+    assert_equal true, a.critical_miss    
+  end
+
+  def test_attack_critical_hit
+    a = Attack.new(10, 98, 5)
+    
+    assert_equal 113, a.attack_value
+    assert_equal 98, a.r1
+    assert_equal 5, a.r2
+    assert_equal 10, a.challenge_rank    
+    assert_equal true, a.critical_hit
+    assert_equal false, a.critical_miss    
+  end
+  
+  def test_middle_earth_combat_get_damage
+    srand(42)
+    d1 = MiddleEarthCombat.get_damage(@a2, @a3)
+    srand(42)    
+    d2 = MiddleEarthCombat.get_damage(@a3, @a2)
+    expected = 103
+    
+    assert_equal expected, d1
+    assert_equal expected, d2
+  end
+
+  def test_middle_earth_combat_get_damage_tie
+    expected = 0
+    d = MiddleEarthCombat.get_damage(@a1, @a1)    
+    
+    assert_equal expected, d
+  end
+  
+  def test_middle_earth_combat_do_round_a1_wins
+    me_combat = MiddleEarthCombat.new(@c1, @c2)
+    me_combat.do_round(@a1, @a2, 50)
+    
+    assert_equal 100, @c1.health
+    assert_equal 50, @c2.health
+    assert_equal @a1, me_combat.results[0].attack1
+    assert_equal @a2, me_combat.results[0].attack2    
+    assert_equal 50, me_combat.results[0].damage
+    assert_equal @c1, me_combat.results[0].character1
+    assert_equal @c2, me_combat.results[0].character2
+  end
+  
+  def test_middle_earth_combat_do_round_a2_wins
+    me_combat = MiddleEarthCombat.new(@c1, @c2)
+    me_combat.do_round(@a2, @a1, 75)
+    
+    assert_equal 25, @c1.health
+    assert_equal 100, @c2.health
+    assert_equal @a2, me_combat.results[0].attack1
+    assert_equal @a1, me_combat.results[0].attack2    
+    assert_equal 75, me_combat.results[0].damage
+    assert_equal @c1, me_combat.results[0].character1
+    assert_equal @c2, me_combat.results[0].character2
+
+  end
+
+  def test_middle_earth_combat_do_round_tie
+    me_combat = MiddleEarthCombat.new(@c1, @c3)
+    me_combat.do_round(@a1, @a1)
+    
+    assert_equal 100, @c1.health
+    assert_equal 1, @c3.health
+    assert_equal @a1, me_combat.results[0].attack1
+    assert_equal @a1, me_combat.results[0].attack2    
+    assert_equal 0, me_combat.results[0].damage
+    assert_equal @c1, me_combat.results[0].character1
+    assert_equal @c3, me_combat.results[0].character2
+
+  end
+  
+  def test_middle_earth_combat_do_round_with_dead
+    me_combat = MiddleEarthCombat.new(@c1, @c3)
+    @c3.health = 0
+    
+    assert_raise RuntimeError do
+      me_combat.do_round
+    end
+    
+  end
+
+  def test_middle_earth_combat_do_round_with_nil
+    assert_raise NoMethodError do
+      MiddleEarthCombat.new(@c1, nil)    
+    end
+  end
+  
+  def test_middle_earth_combat_fight_c1_wins
+    srand(42)
+    me_combat = MiddleEarthCombat.new(@c1, @c3)
+    me_combat.fight
+    
+    assert_equal @c1, me_combat.victor
+    assert_equal 100, @c1.health
+    expected_health = -20 #make the editor stop barking
+    assert_equal expected_health, @c3.health
+    assert_equal 1, me_combat.results.size
+    assert_equal @c1.challenge_rank, me_combat.results[0].attack1.challenge_rank
+    assert_equal @c3.challenge_rank, me_combat.results[0].attack2.challenge_rank    
+    assert_equal 21, me_combat.results[0].damage
+    assert_equal @c1, me_combat.results[0].character1
+    assert_equal @c3, me_combat.results[0].character2
+  end
+  
+  def test_middle_earth_combat_fight_c2_wins
+    srand(25)
+    me_combat = MiddleEarthCombat.new(@c1, @c2)
+    me_combat.fight
+    
+    assert_equal @c2, me_combat.victor
+    assert_equal 12, @c2.health
+    assert_equal @c1.health, -115
+    assert_equal 8, me_combat.results.size            
+  end
+
+  def test_middle_earth_combat_fight_with_dead
+    assert_raise ArgumentError do
+      MiddleEarthCombat.new(@c1, @c4)    
+    end    
+  end
+  
+  def test_simulation
+    expected_rounds = 100
+    me_challenge = MiddleEarthChallengeSimulator.new(@c1, @c2, expected_rounds)
+    
+    assert_equal @c1, me_challenge.character1
+    assert_equal @c2, me_challenge.character2
+    assert_equal expected_rounds, me_challenge.num_rounds
+    assert_equal 0, me_challenge.character1_wins
+    assert_equal 0, me_challenge.character2_wins
+    
+    me_challenge.simulate
+    
+    assert(me_challenge.character1_wins > expected_rounds * 0.7)
+    assert(me_challenge.character2_wins < expected_rounds * 0.3) 
+    assert_equal expected_rounds, (me_challenge.character1_wins + me_challenge.character2_wins)
+  end
+
+  def test_simulation_c1_always_win
+    expected_rounds = 10000
+    me_challenge = MiddleEarthChallengeSimulator.new(@c5, @c3, expected_rounds)
+        
+    me_challenge.simulate
+    
+    assert_equal expected_rounds, me_challenge.character1_wins 
+    assert_equal 0, me_challenge.character2_wins        
+  end
+
+  def test_simulation_c2_always_win
+    expected_rounds = 10000
+    me_challenge = MiddleEarthChallengeSimulator.new(@c3, @c5, expected_rounds)
+        
+    me_challenge.simulate
+    
+    assert_equal expected_rounds, me_challenge.character2_wins 
+    assert_equal 0, me_challenge.character1_wins        
+  end
+  
+  def test_simulation_with_dead
+    assert_raise ArgumentError do
+      MiddleEarthChallengeSimulator.new(@c1, @c4, 1)
+    end
+  end
+
+  def test_simulation_with_nil
+    assert_raise NoMethodError do
+      MiddleEarthChallengeSimulator.new(@c1, nil, 1)
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: MeChallenge
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Chesley Coughlin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-18 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: This command line utility simulates n number of personal challenge combats in the PBM game Ware in Middle Earth.
+email: 
+- chesley_coughlin@yahoo.com
+executables: 
+- me_challenge
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/me_challenge
+- lib/me_challenge.rb
+- lib/middle_earth_challenge_simulator.rb
+- test/test_me_challenge.rb
+- test/test_middle_earth_challenge_simulator.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/uwruby
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: uwruby
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: This command line utility simulates n number of personal challenge combats in the PBM game Ware in Middle Earth.
+test_files: 
+- test/test_me_challenge.rb
+- test/test_middle_earth_challenge_simulator.rb