Question

In this project you implement a program such that it simulates the process of repeated attempts to hit a target with a projectile. The goal is to shoot the projectile within a 1 foot distance from the target, since such a short miss is accepted as a hit. Your program is responsible for the following tasks.

Compute the trajectory data of a projectile (such as the time, the maximum height and the distance as described by the formulas above) for a given launch velocity and a launch angle, in particular for an initial choice of a 45 degree angle

Determine if the target is within the range for the given launch velocity, that is check if at the first attempt the distance is sort to the target with more than 1 foot; if so the process is terminated and then restarted with an increased launch velocity (note that for any velocity the longest range is attained if the launch angle is of 45 degrees)

Compute the error of a shot (error = projectile range – distance to target)

Check if the error is less than 1 foot in absolute value (the absolute error); if so, notify the user about the result and terminate the process

Offer the user four chances to modify the launch angle and try to hit the target

Keep track of the smallest absolute error produced by the subsequent attempts; report the best effort to the user

Analysis and Requirements

Input

Initial input values are

    (i) launch velocity (feet/sec)  

(ii) distance to the desired target (feet)

(iii) gravitational acceleration (a constant)

Additional input values are the launch angles for the repeated attempts when apply. The angle must always be in the range of 0.0 – 45.0 degrees.

Distance, velocity and launch angle are solicited from the user on JOptionPane input windows.

Output

Output messages are displayed both on JOptionPane windows and on the console. Every time a launch has been executed by the program, a report providing the details of the trajectory must be displayed.

Design

For this project you shall design a single class which contains all the necessary data and operations. A suggested class name is Projectile. You must decide upon the necessary import(s). The Projectile class contains the main method, which in turn contains all your code, including the variable declarations. The main method is responsible for the following tasks:

 opens a welcoming window

 declares and assigns a named constant for the gravitational acceleration; the value is 32

 declares variables (all double) to store projectile data velocity, distance and angle; all initialized to 0

 solicits the input values as explained in the Analysis section, if either of these input is the empty string or null (Cancel button), the message as shown in Figure 11 displayed and the program exits; valid input parsed and saved in the relevant variables

 computes all the trajectory and output data and saves those in relevant variables (declare and use the necessary variables as specified in the class description below)

 builds up and stores the output message in a single string variable

 displays the output windows

 numbers in the output are formatted to the nearest hundredth; for this purpose, use the String.format( ) method for JOptionPane output; for the console both String.format( ) and printf( ) are applicable; DecimalFormat class is also permitted as explained in the 5th Edition of Gaddis

 utilizes if and/or if-else logic to decide if additional launches are necessary and repeats the operations at most four times as needed (note: heavy code repetition will be necessary to cover all four cases, since using loops is not allowed)

 terminates the program when it is due

Answer 1

import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class Projectile {

   public static void main(String[] args) {

       final double g = 32;
       double velocity = 0, distance = 0, angle = 0;
       double bestAngle = 0, bestDistance = Double.MAX_VALUE;

       JFrame frame = new JFrame("Welcome");
       boolean validInput = false;
       // Display welcome Message
       JOptionPane.showMessageDialog(frame, "Welcome...");
       // Accept distance value
       String distanceStr = JOptionPane.showInputDialog(frame,
               "Enter Traget Distance");
       ;
       if (distanceStr == null || distanceStr.isEmpty())
           System.exit(0);
       distance = Double.parseDouble(distanceStr);
       while (!validInput) {
           // Accept launch velocity value
           String velocityStr = JOptionPane.showInputDialog(frame,
                   "Enter Launch Velocity");
           if (velocityStr == null || velocityStr.isEmpty())
               System.exit(0);
           velocity = Double.parseDouble(velocityStr);
           validInput = checkValidInput(distance, velocity, g);
       }
       boolean hit = false;
       // Attempt 4 times
       double range = 0;
       do {
           String angleStr = JOptionPane.showInputDialog(frame,
                   "Enter Launch Angle");
           if (angleStr == null || angleStr.isEmpty())
               System.exit(0);
           angle = Double.parseDouble(angleStr);
           range = getRange(velocity, g, angle);
       } while (angle < 0 || angle > 45.0); // Re-enter angle value is value is
                                               // not in range 0 - 45.0
       if (Math.abs(distance - range) < bestDistance) {
           // Save best attempt
           bestDistance = Math.abs(distance - range);
           bestAngle = angle;
       }
       if (Math.abs(distance - range) < 1.0) {
           hit = true;
       } else {
           // Display report
           String outputText = "MISSED!\n"
                   + getReport(distance, range, velocity, angle, g);
           System.out.println(outputText);
           JOptionPane.showMessageDialog(frame, outputText);
       }
       if (!hit) {
           range = 0;
           do {
               String angleStr = JOptionPane.showInputDialog(frame,
                       "Enter Launch Angle");
               if (angleStr == null || angleStr.isEmpty())
                   System.exit(0);
               angle = Double.parseDouble(angleStr);
               range = getRange(velocity, g, angle);
           } while (angle < 0 || angle > 45.0); // Re-enter angle value is
                                                   // value is not in range 0 -
                                                   // 45.0
           if (Math.abs(distance - range) < bestDistance) {
               // Save best attempt
               bestDistance = Math.abs(distance - range);
               bestAngle = angle;
           }
           if (Math.abs(distance - range) < 1.0) {
               hit = true;
           } else {
               // Display report
               String outputText = "MISSED!\n"
                       + getReport(distance, range, velocity, angle, g);
               System.out.println(outputText);
               JOptionPane.showMessageDialog(frame, outputText);
           }
       }

       if (!hit) {
           range = 0;
           do {
               String angleStr = JOptionPane.showInputDialog(frame,
                       "Enter Launch Angle");
               if (angleStr == null || angleStr.isEmpty())
                   System.exit(0);
               angle = Double.parseDouble(angleStr);
               range = getRange(velocity, g, angle);
           } while (angle < 0 || angle > 45.0); // Re-enter angle value is
                                                   // value is not in range 0 -
                                                   // 45.0
           if (Math.abs(distance - range) < bestDistance) {
               // Save best attempt
               bestDistance = Math.abs(distance - range);
               bestAngle = angle;
           }
           if (Math.abs(distance - range) < 1.0) {
               hit = true;
           } else {
               // Display report
               String outputText = "MISSED!\n"
                       + getReport(distance, range, velocity, angle, g);
               System.out.println(outputText);
               JOptionPane.showMessageDialog(frame, outputText);
           }
       }
       if (!hit) {
           range = 0;
           do {
               String angleStr = JOptionPane.showInputDialog(frame,
                       "Enter Launch Angle");
               if (angleStr == null || angleStr.isEmpty())
                   System.exit(0);
               angle = Double.parseDouble(angleStr);
               range = getRange(velocity, g, angle);
           } while (angle < 0 || angle > 45.0); // Re-enter angle value is
                                                   // value is not in range 0 -
                                                   // 45.0
           if (Math.abs(distance - range) < bestDistance) {
               // Save best attempt
               bestDistance = Math.abs(distance - range);
               bestAngle = angle;
           }
           if (Math.abs(distance - range) < 1.0) {
               hit = true;
           } else {
               // Display report
               String outputText = "MISSED!\n"
                       + getReport(distance, range, velocity, angle, g);
               System.out.println(outputText);
               JOptionPane.showMessageDialog(frame, outputText);
           }
       }
       String str = "";
       if (hit) {
           str = "HIT!!!\n"
                   + getReport(distance, getRange(velocity, g, bestAngle),
                           velocity, angle, g);
       } else {
           str = "Best Attempt\n"
                   + getReport(distance, getRange(velocity, g, bestAngle),
                           velocity, angle, g);
       }
       // Display final report
       System.out.println(str);
       JOptionPane.showMessageDialog(frame, str);
   }

   // Method to get projectile details as string
   private static String getReport(double distance, double range,
           double velocity, double angle, double g) {
       StringBuilder str = new StringBuilder();
       str.append("Target Distance: " + String.format("%.2f", distance) + "\n");
       str.append("Launch Velocity: " + String.format("%.2f", velocity) + "\n");
       str.append("Launch Angle: " + String.format("%.2f", angle) + "\n");
       str.append("Range: " + String.format("%.2f", range) + "\n");
       str.append("Time of flight: "
               + String.format("%.2f", findTimeOfFlight(velocity, angle, g))
               + "\n");
       str.append("Maximum height reached: "
               + String.format("%.2f", findMaximumHeight(velocity, angle, g))
               + "\n");
       str.append("Correction in Range Required: "
               + String.format("%.2f", distance - range));
       return str.toString();
   }

   // Method to find maximum height
   private static double findMaximumHeight(double velocity, double angle,
           double g) {
       double height = Math.pow(velocity * Math.sin(Math.toRadians(angle)), 2)
               / (2 * g);
       return height;
   }

   // Method to find time of flight
   private static double findTimeOfFlight(double velocity, double angle,
           double g) {
       double time = 2 * velocity * Math.sin(Math.toRadians(angle)) / g;
       return time;
   }

   // Method to check if launch velocity can attain target distance
   private static boolean checkValidInput(double distance, double velocity,
           double g) {
       double range = getRange(velocity, g, 45.0);
       if (distance - range > 1.0)
           return false;
       else
           return true;
   }

   // Method to calculate range of the projectile
   private static double getRange(double velocity, double g, double angle) {
       double range = velocity * velocity
               * Math.sin(2 * Math.toRadians(angle)) / g;
       return range;
   }

}