I ordered this earlier today. Order number #162246359.
I do not have access to my old account.
I sent the first half of the payment to you.
I am going to request a refund for the second half.
Do I need to resend the assignment?
Thanks!
Pam

Begin with several insects walking around the screen. The user must click the mouse on an insect to kill it. The user must kill as many insects as possible in 30 seconds.
Keep an on-screen count of the number of insects killed and an on-screen timer counting down form 30 seconds. The game should get harder as it proceeds, so make the insects move faster with each kill. After 30 seconds the game ends.
Use an image editing software to draw an animated insect. There should also be an image for it being dead.
Animate the insect so it faces the direction it is moving.
It is recommended that you define a class to represent an insect and use an array of objects to create several insects.
Note-The player must “click” on an insect to kill it. Do not simply test if the mouse button is pressed while the pointer is on the insect, as this lets the player click once and simply drag around to score kills. Too easy!

My professor wrote a whole java prgram with the classes and all, what needs to be done is 3 functions and the instructions are on the file Board.java.

Please, I know the deadline is soon but it was given recently and I could not do it.
Its just 3 functions.

You work with the given project hauntedCastleStart. This is yet another variant of the game of Zuul that is described in Chapter 8 of the module text book. This variant uses a dierent scenario, namely a haunted castle. You will extend the project towards a more interesting game.

# Assignment 3 – Inheritance, Abstract Classes, Interfaces, and Polymorphism

## Due: 02-19-2020

## Author

## Description

The Jawas on Tatooine have recently opened a droid factory and they want to hire you to write a program to hold a list of the available droids, and the price of each droid. The price is based on the type: (protocol, utility, janitor, or astromech), the material used and the options selected by the Jawa creating the list.

The program will keep a list of Droids that are created. This list MUST be an Array. The array should be of a type that is high enough on the inheritance chain that all droids no matter what type they are can be stored in it (Think Polymorphism). Don’t make it of type ‘object’. That is too high on the inheritance chain. Also, just make the size of the array large enough that it can accommodate some droids. 100 is a good number that comes to mind. I’m not concerned with it being auto-resizing, or anything fancy.

A Jawa will be presented with a user interface to add a new Droid, or print the current Droid list. Adding a new Droid will require input from the Jawa to create the new droid. Once all of the needed information is added for the droid, the new droid will be added to the droid collection.

If a Jawa decides to print the collection of droids in inventory, the program should loop through all of the droids in the collection and print out the information from ToString, and the TotalCost for each droid. This should be accomplished using Polymorphism to reduce the amount of code needed.

All of the prices for the various aspects of a droid are left up to you to determine. If I was doing it though, I would probably have a small set price for each of the following general options, and not get too specific to save time. ie:
1. A price for model(protocol, utility, etc.)
2. A few different materials (Something Made up), each with a different price
3. A price for each additional option (One of the various option bools listed below. One price for all will work)
4. A price per quantity option such as: numberOfLanguages, and numberOfShips

The program comes with an Interface IDroid that must be implemented by subclasses. It contains a public method called CalculateTotalCost, and a public Property called TotalCost. CalculateTotalCost returns a void, so it’s job is to access the properties of the droid and literally calculate the total cost. It does not return the Total Cost. It only Calculates it.
TotalCost is how you will get access to the total cost of the droid. This will be zero until CalculateTotalCost is called. Then it will have a value.
I didn’t make CalculateTotalCost return the calculated value because I wanted you to have to implement both a method and a property in subclasses. This should also demonstrate how an Interface acts as a contract and requires you to write things a certain way. Even if you don’t agree with it.

You should put all of your UI into a UI class that will handle getting all of the necessary information from the Jawa, and display the feedback to the Jawa.

You should create a class for the collection of the Droids. The DroidCollection class should contain the array that holds the droids, and maintain any internal information needed to manage that array. It should have an add method that will do the work of determining which instance of a droid needs to be created and added to the array. The UI class will prompt for the needed information to add a droid, and then when it has all of the info, it will send it to the add method, which will then determine which type to add based on the ‘model’ that was entered. The add method might be a good place to do method overloading, though not required.

You should follow the concepts about inheritance talked about in class, and work hard at DRY (Don’t Repeat Yourself) Principles.

## Classes

The program should have a base abstract class called Droid with the following variables, properties, constructors, methods, etc that implements the IDroid interface.

Droid:

* Variables: material (string), color (string), baseCost (decimal), totalCost (decimal)
* Constructors: 2 parameter constructor (string, string)
* Property: TotalCost to return the cost of the droid (Required by the interface)
* Public Methods:
    * ToString: return a formatted string containing the variables
    * CalculateTotalCost: Required by the interface
* Protected Methods:
    * CalculateBaseCost: Determines the baseCost based on material and color.

There should be two derived classes from the abstract class Droid with appropriate variables, methods and properties.

Protocol:

* Variables: numberLanguages (int)
* Constant: costPerLanguage
* Constructors: 3 parameter constructor (string, string, int)
    * Uses the base class (Droid) constructor
* Public Methods:
    * ToString: return a formatted string containing the variables
    * CalculateTotalCost: Calculate the totalCost based on the number of languages and type, and then adds it to the base totalCost

Utility:

* Variables: toolbox (bool), computerConnection (bool), arm (bool)
* Constructors: 5 parameter constructor (string, string, bool, bool, bool)
    * Uses the base class (Droid) constructor
* Public Methods:
    * ToString: return a formatted string containing the variables
    * CalculateTotalCost: Calculates totalCost by calculating the cost of each selected option and type, and then add it to the base totalCost.

There should be two more derived classes from the class Utility with appropriate variables, methods and properties.

Janitor:

* Variables: trashCompactor (bool), vacuum (bool)
* Constructors: 7 parameter constructor (string, string, bool, bool, bool, bool, bool)
    * Uses the base class (Utility) constructor
* Public Methods:
    * ToString: return a formatted string containing the variables
    * CalculateTotalCost: Calculate totalCost by calculating the cost of each selected option and type, and then adds it to the base CalculateTotalCost

Astromech:

* Variables: fireExtinquisher (bool), numberShips (int)
* Constant: costPerShip
* Constructors: 7 parameter constructor (string, string, bool, bool, bool, bool, int)
    * Uses the base class (Utility) constructor
* Public Methods:
    * ToString: return a formatted string containing the variables
    * CalculateTotalCost: Calculate totalCost by calculating the cost of each selected option, the cost based on the number of ships, and the type. Then add all of that to the base CalculateTotalCost


## Solution Requirements

Solution Must:

* Allow Jawa to add a new droid of either (Protocol, Utility, Janitor, or Astromech) to the list
* Allow Jawa to print the list of droids out.
* Create abstract class Droid that implements IDroid
* Derive two classes (Protocol and Utility) from the class Droid
* Derive two classes (Janitorial and Astromech) from the class Utility
* Each derived class (Protocol, Utility, Janitor, and Astromnech) must either implement or override the ToString and CalculateTotalCost methods
* Create a UI class
* Create a DroidCollection class
* Use private, public and protected appropriately.
* Use abstract, virtual, and override appropriately.
* Have sufficient comments about what you are doing in the code.

### Notes

If you did not do well on Assignment 1, you may want to look at the Assignment 1 Key that I did for some help related to UI classes, Collection classes, arrays, and structure.

It may be beneficial for you to create extra methods within the droid sub classes. You are not limited to the ones mentioned. You may even find it useful to make some additional ones that are protected and virtual.

## Grading
| Feature                    | Points |
| ————————– | —— |
| Droid Class                | 10    |
| Protocol / Utility        | 15    |
| Janitor / Astromech        | 15    |
| ToString / Total Cost      | 10    |
| UI Class                  | 10    |
| Droid Collection          | 10    |
| Add Droid / Print List    | 10    |
| Access Modifiers Correct  | 5      |
| Abstract / Virtual Correct | 5      |
| Documentation              | 5      |
| README                    | 5      |
| **Total**                  | **100**|

## Outside Resources Used
StackOverFlow.com
prior assingments or inclass work

## Known Problems, Issues, And/Or Errors in the Program

Create a soccer game using preferably either Visual Basic or Unity. It must be a simple game with the title ‘Galactik Football’. With a fire ball effect when players take a shot. Controls will be W,A,S,D keys to move up,left,down and right. Mouse will be used to pass/shoot and aim. Use retro pixelated type graphics.

Please try to get this done as soon as you can i will be forever grateful!

You will write code that, given a document (a sequence of words) and set of search terms, will find the minimal length subsequence in the document that contains all of the search terms. If there are multiple subsequences that have the same minimal length, you may return any one of them.

This is the class you will write. We have provided you with a skeleton of the class for you to fill in. As you will see, the constructor for the class does most of the work, including locating the minimum snippet containing a list of terms in a given document.

For a complete description of what you must implement in this class, please see the Javadoc for the MinimumSnippet class. Read this document very thoroughly and carefully!

Code must be written to satisfy this.

The program for this Assessment will consist of four sections, each headed by the three-line comment below:
//*********************************************************
//****Assessment 5 Section X
//*********************************************************
(where X stands for the portion of the Assessment to follow.)

Section 1:
1. Enter the comment with the section title as described above.
2. Create a base class called scoreKeeper.
    * Include a private property called gamePlayed to contain the name of the game being played.
    * Add a private property which will allow for any number of players. A dictionary or dynamic array would be a good option. The container will hold the names and scores of the players.
    * Include a new public method, addName(), to accept a players name and insert it into the container. (Note: If the container you used does not have an add method to easily add a value, you will need to include code to determine the next available position.)
    * Include a public method, getPlayerName(), to accept the number of the player and return the players name.
    * Include a public method setGame() to update the gamePlayed property by passing it a string containing the name of the game.
    * Include a public method getGame() to retrieve the name of the game.
    * Include a public method, addScore(), to update a players score by passing it the players name and the points to be added. Return the updated score.
    * Include a public method, subScore(), to update a players score by passing it the players name and the points to be subtracted. Return the updated score.
    * Include a new public method, listAllScores(), to print the name of the game being played, the names of each player and their respective scores.
    * Include two constructors. The first one is a default constructor. The second is a constructor method which will accept the name of the game and call the setGame().

Section 2:
1. Enter the comment with the section title as described above.
2. Some games have additional information that must be monitored during play. Create a sub-class called baseball that inherits from the base class scoreKeeper.
    * Add private integer properties for fouls, balls, strikes, and outs.
    * Add a private decimal property to hold the inning number. Whole numbers will indicate the top of the inning and half numbers will indicate the bottom. e.g. 5.5 would indicate the bottom of the 5th
    * Include a public method, advOuts(), to add 1 to the number of outs. If the number of outs reaches 3, reset balls, strikes, fouls and outs to 0 and add .5 to innings.
    * Include a public method, getOuts(), to return the current number of outs.
    * Include a public method, advStrikes(), to add 1 to the number of strikes. If the number of strikes reaches 3, call advOuts().
    * Include a public method, getStrikes(), to return the current number of strikes.
    * Include a public method, advFouls(), to add one to the number of fouls. If the number of strikes is less than 2, advFouls() should also add one to strikes.
    * Include a public method, getFouls(), to return the current number of fouls.
    * Include a public method, advBalls(), to add one to the number of balls. If the number of balls reaches 4, reset balls, strikes and fouls. (This means the player has been given a walk to first base but does not guarantee and runs were scored.
    * Include a public method, getBalls(), to return the current number of balls.
    * Include a public method, getInning(), to return the current inning.
    * Include two constructors. The first one is a default constructor. The second is a constructor method which will accept the name of the home team followed by the name of the visiting team. It will then call the setGame() and pass it a combined name such as Cubs vs Braves. It will also call the addName() method to add the two teams to the players property.

Section 3:
1. Enter the comment with the section title as described above.
2. Write code to test the base class. This can be done multiple ways and should be when throughly testing your code. However, for this Assessments output, we will use the following method:
    * Print to the console the message, Assessment 10 Classes and Inheritance followed by a blank line.
    * Print Section 3: Base Class Results After Adding to the console followed by a blank line.
    * Instantiate an object called gameOne, from the scoreKeeper class, passing Canasta as the game name to the constructor.
    * Call the addName() method three times to add the players, Larry, Moe, and Curly.
    * Print a blank line to the console for ease of reading.
    * Call the objects addScore() method three times. Once for Larry adding 20 points to his score. A second time for Moe adding 35 points to Curlys score. Then a third time for Curly, adding 45 points to Curlys score.
    * Using the listAllScores() method, print a report of the players and their respective scores to the console.
    * Call the objects subScore() method twice. Once for Moe subtracting 15 points from his score. The second time, subtract 5 points from Curlys score.
    * Print Section 3: Base Class Results After Subtracting to the console followed by a blank line
    * Using the listAllScores() method, print a report of the players and their respective scores to the console.
    * Print two blank lines to the console.

Section 4:
1. Enter the comment with the section title as described above.
2. Write code to test the sub-class. This can be done multiple ways and should be when thoroughly testing your code. However, for this Assessments output, we will use the following method:
    * Print Section 4: Derived Class Results: Baseball scoring to the console followed by a blank line.
    * Instantiate an object called gameTwo, from the baseball class, passing Cubs and Braves as the teams, (or teams of your choosing), to the constructor. (Note: If you choose to use different team names, be sure you substitute them below for Cubs or Braves.
    * The following method calls should be done in order to guarantee the correct results.
        * Call the addScore() method to advance the Cubs score by 2.
        * Call the advOuts() method three times.
        * Call the addScore() method to advance the Braves score by 3.
        * Call the advOuts() method once.
        * Call the advStrikes() method once.
        * Call the advFouls() method thrice.
        * Call the advBalls() method once.
        * Call the listAllScores() method to print the game and scores. Also, print a blank line to the console.
        * Use the appropriate get methods to print the current inning, outs, strikes, fouls, and balls.

EXPECTED OUTPUT
Assessment 10 – Classes and Inheritance
Section 3: Base Class Results After Adding
The scores for Canasta:
Larry’s score is 20
Moe’s score is 35
Curly’s score is 45
 
Section 3: Base Class Results After Subtracting
The scores for Canasta:
Larry’s score is 20
Moe’s score is 20
Curly’s score is 40
 
Section 4: Derived Class Results: Baseball scoring
The scores for Cubs vs Braves:
Cubs’s score is 2
Braves’s score is 3
 
The current inning is 1.5
Outs: 1
Strikes: 2
Fouls: 3
Balls: 1

You are very welcome to use online resources to help you carry out these tasks. You MUST cite (in the code comments or in an adjacent cell) if you use code or tutorials that you have got from another source. A brief statement and a link to the material is considered acceptable acknowledgement.