From 774a1b122f16fc7e2f1da13f958173090214a909 Mon Sep 17 00:00:00 2001 From: Sarah Nahmias Date: Thu, 25 Feb 2016 10:46:23 -0800 Subject: [PATCH] These are my planet and solar system class objects. --- planet.rb | 205 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 205 insertions(+) create mode 100644 planet.rb diff --git a/planet.rb b/planet.rb new file mode 100644 index 00000000..4762154a --- /dev/null +++ b/planet.rb @@ -0,0 +1,205 @@ +=begin +2/22/2016 - Solar System +Purpose: Let's make a planetary system! + +Baseline + +*Create a Planet class with a name attribute. +*You should be able to instantiate a new Planet object with an associated name. + +Wave 1 + +Primary Requirements + + *Get creative! Give each instance of Planet at least five attributes. + These could be diameters, mass, moons... whatever! + --- DONT DO YET Allow these attributes to be set using a hash in initialize. + *You should be able to create many different planets with different properties, + like Mercury, Venus, Earth, Mars, Jupiter, etc. + +Optional Enhancements + + Give each planet a rate of solar rotation + Give each planet a @distance_from_the_sun attribute + *Write a program that asks for user input to query the planets: + *First, ask the user to select a planet they'd like to learn about. + *Present the user with a list of planets from which they can choose. Something like: + 1. Mercury, 2. Venus, 3. Earth, 4. Secret Earth, 5. Mars, 6. Jupiter, ... 13. Exit + *Provide the user with well formatted information about the planet + (diameter, mass, number of moons, primary export, etc.) + *Then ask the user for another planet. +=end + +=begin +Wave 2 + +Primary Requirements + +Create a SolarSystem class that has an attribute planets that has zero to many Planet instances. +There are a few different options for how to associate the planets with your solar system: + Initialize the list of planets in the constructor of the solar system + Create a method that adds a single planet to a solar system + Create a method that adds a list of planets to the existing list of planets + +Optional Enhancements + +Ensure that the each planet has a @distance_from_the_sun attribute. +Using this data, add a method to determine the distance from any other planet + (assuming planets are in a straight line from the sun) +Give your solar system a formation year (in earth years). +Define a method that returns the local year of the planet based on it's rotation since the beginning of the solar system +=end + +#wave2 - we are making a more general class called Solar Solar_System + +class Solar_System + attr_reader :planet_array, :planet_hash + + def initialize(planets_array) + @planet_array = planets_array #for some things an array is simpler (ie, printing) + + planet_hash = {} + planets_array.each do |planet| # we want to store planets (variable names) within Solary System as a hash. We will do this by iterating over the array! + planet_hash[planet.name] = planet + end + # this loop level of abstraction is way easier than inputting manually! + @planet_hash = planet_hash #but for most things an array might be simpler. Nice to have both options! + end + + def print_system_planets + @planet_array.each do |planet| + puts " #{planet.name}" # tab for formatting (pretty) + end + end + + def add_new_planet + puts "Cool! So there is a new planet in our solar system. Why don't you tell me about it?" + print "Name the new planet (no spaces, please)! > " + name = gets.chomp + puts "Please answer the following questions so I can update the Solar System records. If you don't know the answer, just hit enter." + print "What is the planet's position from the sun? > " #this could end up with a funky result because we already ordered 9 Planets (the known planets in the solar system) + position_from_sun = gets.chomp + print "How many moons does it have? > " + num_moons = gets.chomp + print "What is its mass (in Earth masses)? > " + mass = gets.chomp + print "How long does one rotation take (in hours)? > " + rotation = gets.chomp + print "How long does one revolution take (in days)? > " + revolution = gets.chomp + print "What is its distance from the sun (in million miles)? > " #again, what if distance doesn't match order? + distance_from_the_sun = gets.chomp + + new_planet = Planet.new(name: name, position_from_sun: position_from_sun, num_moons: num_moons, + mass: mass, rotation: rotation, revolution: revolution, distance_from_the_sun: distance_from_the_sun) + + @planet_array << new_planet #update array + @planet_hash[new_planet.name] = new_planet #update hash + + end + + +end + +# Baseline - wave 1, creates class for Planets +class Planet + attr_reader :name, :position_from_sun, :num_moons, :mass, :rotation, :revolution, :distance_from_the_sun + + def initialize(options) + + @name = options[:name] + @position_from_sun = options[:position_from_sun] || "??" + @num_moons = options[:num_moons] || "??" + @mass = options[:mass] || "??" # in Earth masses + @rotation = options[:rotation] || "??" #hours + @revolution = options[:revolution] || "??" #days + @distance_from_the_sun = options[:distance_from_the_sun] || "??" # million miles + # added the default values of "??" incase user adds a planet without information. + # Printing will still be nice with "??" in print_planet_specs + # Didn't work as expected - will need to trouble shoot later. Empty string made by immediately hitting enter is as truthy as "??" + + end + + def print_planet_specs + + puts "Here is what I know about #{@name}: + + It is the #{@position_from_sun} planet from the Sun! + It has #{@num_moons} moons! + It has a mass of #{@mass} Earth masses! + It takes #{@rotation} hours to complete a rotation! + It takes #{@revolution} days to go around the Sun! + " + end +end + +mercury = Planet.new(name: "Mercury", position_from_sun: "first", num_moons: 0, + mass: 0.0553, rotation: 1411.44, revolution: 87.97, distance_from_the_sun: 36) +venus = Planet.new(name: "Venus", position_from_sun: "second", num_moons: 0, + mass: 0.815, rotation: 5848.56, revolution: 224.7, distance_from_the_sun: 67.2) +earth = Planet.new(name: "Earth", position_from_sun: "third", num_moons: 1, + mass: 1, rotation: 23.9345, revolution: 365.26, distance_from_the_sun: 93) +mars = Planet.new(name: "Mars", position_from_sun: "fourth", num_moons: 2, + mass: 0.107, rotation: 24.623, revolution: 686.98, distance_from_the_sun: 141.6) +jupiter = Planet.new(name: "Jupiter", position_from_sun: "fifth", num_moons: 63, + mass: 317.83, rotation: 9.925, revolution: 4328.9, distance_from_the_sun: 483.6) +saturn = Planet.new(name: "Saturn", position_from_sun: "sixth", num_moons: 61, + mass: 95.162, rotation: 10.5, revolution: 10752.9, distance_from_the_sun: 886.7) +uranus = Planet.new(name: "Uranus", position_from_sun: "seventh", num_moons: 32, + mass: 14.536, revolution: 17.24, rotation: 30663.65, distance_from_the_sun: 1784.0) +neptune = Planet.new(name: "Neptune", position_from_sun: "eighth", num_moons: 18, + mass: 17.147, revolution: 16.11, rotation: 60148.35, distance_from_the_sun: 2794.4) +pluto = Planet.new(name: "Pluto", position_from_sun: "ninth", num_moons: 3, + mass: 0.0021, revolution: 153.72, rotation: 90403.2, distance_from_the_sun: 3674.5) + +planets = [mercury, venus, earth, mars, jupiter, saturn, uranus, neptune, pluto] +#planets we know about! + +solar_system = Solar_System.new(planets) + + puts "Hello! I can tell you some things about the planets in the solar system!" + +ask_for_planet = "Which planet would you like to learn about?" + +puts ask_for_planet +solar_system.print_system_planets #this puts a list of planets, so we don't puts it +#we also can't set it equal to a variable because it returns nil (due to puts) +#prints all the planets we have stored in the solar system +#so the list updates as user adds more planets + + +prompt = "If you don't want to be here, please enter quit. +If you want to add a new planet, enter new. +Otherwise, enter a planet selection: > " +print prompt + +while planet_choice = gets.chomp # loop while getting user input + planet_choice.capitalize! #capitalize so the format matches, however the user inputs + + if solar_system.planet_hash[planet_choice] != nil #if we haven't made the planet, the hash will be nil. + #Otherwise, it would return the variable/object of planet class. + planet = solar_system.planet_hash[planet_choice] + + planet.print_planet_specs #prints out chunk of text about planets + print prompt + + elsif planet_choice == "New" #will call a method from solar_system? + solar_system.add_new_planet + + puts "That was great! Thanks!" + puts ask_for_planet + solar_system.print_system_planets #puts possible_planets + print prompt #print the prompt, so the user knows to re-enter input + + elsif planet_choice == "Quit" + puts "That was fun - see you later :)." + break #so we don't run this loop forever! + + else + puts "That's not a planet I recognize. Please try again!" + + puts ask_for_planet + solar_system.print_system_planets #puts possible_planets + print prompt #print the prompt, so the user knows to re-enter input + end +end