stattr 0.1.0 → 0.1.1

data/lib/stattr.rb

@@ -4,177 +4,207 @@
 
 module Stattr
 
-  # How many sides the most common die has - rewrite to fit your game. 
+  # The Class that defines, in other applications, the "rules" of that game - the stats, the  sides of a given die, and so on.
   #
-  DICE_SIDES = 6 
-    
-  # Represents a single instance of the result of a dice roll  
-  # 
-  class DiceRoll 
-    
-    # @attribute sides [Integer] The number of sides the dice in this roll have. 
+  class Game
+
+    # How many sides the generating dice have in this game.
+    #
+    # @return [Integer]
+    #
+    def self.dice_sides
+      6
+    end #self.dice_sides
+
+    # The number of dice required to create a stat in this game
+    #
+    # @return [Integer]
+    #
+    def self.dice_num
+      3
+    end #self.dice_num
+
+    # The math for generating a stat.
     #
+    # @return [Object]
+    #
+    def self.make_stat(val=1)
+      Stat.new(DiceRoll.new_roll(Game.dice_sides, Game.dice_num))
+    end #make_stat
+
+    # The list of stats for this game.
+    #
+    # @return [Array]
+    #
+    def self.stats
+      ["str", "con", "wis", "int", "cha", "dex"]
+    end #self.stats
+  end #Game
+
+  # Represents a single instance of the result of a dice roll
+  #
+  class DiceRoll
+
+    # @attribute sides [Integer] The number of sides the dice in this roll have.
     # @attribute count [Integer] The number of die being rolled.
     #
     attr_accessor :sides, :count
-    
+
     # New instance of DiceRoll.
     #
     # @param [Integer] sides
-    #
     # @param [Integer] count
-    #
     # @return [Object] DiceRoll object
     #
-    def initialize(sides=DICE_SIDES, count=1)
+    #def initialize(sides=DICE_SIDES, count=1)
+    def initialize(sides=Game.dice_sides, count=Game.dice_num)
       @sides = sides
       @count = count
     end #initialize
-     
-    # Roll a new die. 
+
+    # Roll a new die.
     #
     # @param [Integer] sides
-    #
     # @param [Integer] count
+    # @return [Object] DiceRoll object
     #
-    # @return [Object] DiceRoll object 
-    #
-    def self.new_roll(sides = DICE_SIDES, count=1)
-      # make a new dice object, then roll it. 
+    def self.new_roll(sides = Game.dice_sides, count=Game.dice_num)
+      # make a new dice object, then roll it.
       new(sides, count).roll
     end #self.roll
-   
+
     # From 1 to count, that many [sides] sided die.
-    # 
-    # @return [Integer] Gives each outcome to Roll. 
+    #
+    # @return [Integer] Gives each outcome to Roll.
     #
     def rolls
       (1..count).map { |d| rand(sides) + 1 }
     end #rolls
-    
-    # Adds the rolls from rolls together. 
+
+    # Adds the rolls from rolls together.
     #
-    # @return [Integer] combined rolls 
+    # @return [Integer] combined rolls
     #
     def roll
       rolls.inject(0) { |total, d| total += d }
     end #roll
   end #DiceRoll
 
-  # Represents the list of Statistics that a player has. 
+  # Represents the list of Statistics that a player has.
   #
-	class StatList 
+  class StatList
 
-    # A list of all stats. Currently locked into D+D style stats. 
+    # Creates an attr_accessor for each stat in STAT
     #
-	  attr_accessor :str, :dex, :cha, :con, :wis, :int
-
-    # Create a new Statlist. 
+    # @attribute STATS [Integer] any number of Stats.
     #
-    # @param [Array] str
-    #
-    # @param [Array] dex
-    #
-    # @param [Array] cha
+    attr_accessor *Game.stats
+
+    # Creates a new StatList object. each stat in STAT is an attribute, with the result of makestat assigned to it
     #
-    # @param [Array] con
+    def initialize
+       Game.stats.each { |s| instance_variable_set("@#{s}", Game.make_stat) }
+    end #initialize
+
+    # Allow manual setting of stats.
     #
-    # @param [Array] wis
+    # @param [Attribute] stat
+    # @param [Integer] val
     #
-    # @param [Array] int
+    def set_stat(stat, value)
+      send "#{stat}=", Stat.new(value)
+    end #set_stat
+  end #StatList
+
+  #  Representing a stat in a game.
+  #
+  class Stat
+
+    # @attribute val [Integer] The value of the stat
+    # @attribute mod [Integer] The Calculated modifier of the stat
     #
-    def initialize(str=10, dex=10, cha=10, con=10, wis=10, int=10)  
-      @str = modstat(str)
-      @dex = modstat(dex) 
-      @cha = modstat(cha)
-      @con = modstat(con)
-      @wis = modstat(wis)
-      @int = modstat(int)
-    end #initialize
-    
-    # Takes a given value of a stat and creates a D+D style modifier. 
+    attr_accessor :val, :mod
+
+    def initialize(value)
+      @val= value
+      @mod= modstat(value)
+    end
+    # Creates stat/mod array.
     #
-    # @return [Array] modlist. [0] is the stat, [1] is the modifier. 
+    # @return [Integer] modlist. Returns the modifier. 
     #
     def modstat(r)
       modr = ((r-10)/2).to_int
-      modlist = [r, modr]
-      modlist
     end #modstat
-  end #StatList
-  
-  # CharacterSheet of a given PlayerCharacter. 
-  #
-	class CharacterSheet 
 
-    # @attribute stats [Object] A StatList object 
+    # makes a Stat/mod combination
+    #
+    # @return [Array]
     #
-    # @attribute name [String] The Player Character's name 
+  end #Stat
+
+  # CharacterSheet of a given PlayerCharacter.
+  #
+  class CharacterSheet
+
+    # @attribute stats [Object] A StatList object
+    # @attribute name [String] The Player Character's name
     #
-  	attr_accessor :stats, :name
+    attr_accessor :stats, :name
 
     # new instance of CharacterSheet
+    # @param [String] name
     #
-    # @param [String] name 
-    #
-  	def initialize(name) # :notnew:
-    	@name = name
-      # creates StatList object with '10' as a default for each. 
-    	@stats = StatList.new(10,10,10,10,10,10)
-  	end #initialize 
-		
-    # This is how you roll a brand new random character. 
-    #
-    # @param [String] name 
-    #
-    # @return [Object] New Charactersheet 
-    #
-		def self.roll_char(name)
-      char = CharacterSheet.new(name) 
-      char.stats = StatList.new(
-      DiceRoll.new_roll(DICE_SIDES, 3),
-      DiceRoll.new_roll(DICE_SIDES, 3),
-      DiceRoll.new_roll(DICE_SIDES, 3),
-      DiceRoll.new_roll(DICE_SIDES, 3),
-      DiceRoll.new_roll(DICE_SIDES, 3),
-      DiceRoll.new_roll(DICE_SIDES, 3)
-      )
-		  char	
-		end # self.roll_char
-	end #CharacterSheet
-  
-  # Player class represents a human, who may have multiple character sheets. 
-  #
-  class Player 
-  
-  # @attribute fname [String] The First Name of the Player   
-  #
-  # @attribute lname [String] The last Name of the Player   
+    def initialize(name)
+      @name = name
+      @stats = StatList.new
+    end #initialize
+
+    # This is how you roll a brand new random character.
+    #
+    # @param [String] name
+    # @return [Object] New Charactersheet
+    #
+    def self.roll_char(name)
+      char = CharacterSheet.new(name)
+      char.stats = StatList.new
+      char
+    end # self.roll_char
+  end #CharacterSheet
+
+  # Player class represents a human, who may have multiple character sheets.
   #
+  class Player
+
+  # @attribute fname [String] The First Name of the Player
+  # @attribute lname [String] The last Name of the Player
   # @attribute characters [Array] An array containing Charactersheet objects
   #
   attr_accessor :fname, :lname, :characters
-    
+
     # Create new Player object
     #
     # @param [String] fname
-    #
     # @param [String] lname
     #
-    def initialize(fname, lname) 
+    def initialize(fname, lname)
       @fname = fname
-      @lname = lname 
+      @lname = lname
       @characters = []
     end #initialize
-  
-    # Creates a new randomly generated character associated with Player 
+
+    # Creates a new randomly generated character associated with Player
     #
-    # @param [String] name 
+    # @param [String] name
     #
     def new_char(name)
       new_char = CharacterSheet.roll_char(name)
-      self.characters << new_char 
+      self.characters << new_char
     end #roll_char
   end #Player
-      
+
+  # DM class extends player, fresh for modifying.
+  #
+  class DM < Player
+  end #DM
 end #Stattr

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stattr
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-24 00:00:00.000000000 Z
+date: 2012-05-25 00:00:00.000000000 Z
 dependencies: []
 description: Stattr is a Gem that includes a number of useful functions for rolling
   dice in a game like Dungeons and Dragons.