Assignment 4 - Extend Recursive Animal Editor

Guidelines

Due at 11.59pm, Friday, April 6

You are graded on the completeness, neatness, comments, and visual style of your final assignment
All assignments are individual
ONE SKETCH ONLY
ZIP YOUR SKETCH FOLDER (not individual files) INTO ONE ZIP FILE
Submit to Canvas before the deadline

There is no late policy for this course!

If you do not complete the assignment by the deadline, you will receive a lousy grade

Overview:

You will extend your animal editor.

Old Animal Editor Brief:

Create a sketch that allows you to draw an animal with the keyboard and/or mouse controlling the parameters. Like the previous recursive tree, you will greate a tree-like structure for the limbs of your animal. The Root node represents the torso, and there will be a number of arms/legs that are connected to the torso. Consider that each articulated body part in the tree is an instance of a class that has the visual and geometric properties of the body. The mouse and/or keyboard interaction allows you to control some of the appearance of each part.

You need to create a structure that stores info about the current body part, and has pointers/references to child instances. You need to store information about the bounding box of each drawable part of the animal so that you can select it and edit it. You will need to use PVectors for this, because PVector allows you to do things like
PVector v1 = new PVector( 10.0, 5.0 ); v1.rotate( HALF_PI );

With a limb selected, you should have a little control panel in your editor to adjust the appearance of it. Appearance could mean color or angle, or anything suitable.

The New Stuff

Implementing Interfaces

You are provided with two jar files: interfacelib.jar and reflections.jar (available via Canvas). These are similar to core.jar and controlP5.jar. You are required to add these libraries to your Netbeans project.

interfacelib.jar provides two interfaces: Scrubbable and CreatureFactory.

Scrubbable

Your Animal component(s) must impelemnt the Scrubbable interface. The Scrubbale interface provides following functions:

```
String getName()
```
This method should return the unique name of the component. Every animal component should have a name. For example, if you create a class called Leg for an Animal with four legs, the names for the legs can be "Leg1", "Leg2", "Leg3", and "Leg4"
```
void setName(String name)
```
This method should set the name of the component to value in name
```
String[] getProperties()
```
This method returns an array of the names of the parameters that are settable/gettable above
```
void setParameter( String name, float value )
```
This method takes a String that names a parameter in your base class, and sets that parameter to the value in value.
```
float getParameter( String name )
```
This method takes a String that names a parameter in your base class, returns the value of that variable.
```
void draw()
```
This method recursively draws the component. You probably already have this method in your components
```
Scrubbable pick(int mouseX, int mouseY)
```
This method takes the x and y coordinates for the mouse and checks if a component or a child component of a component was selected. If yes, returns the animal component that was clicked. If nothing was clicked/selected, this method returns null
```
Iterator createIterator()
```
This method returns an iterator for the Scrubbable class.

CreatureFactory

You will also create a single class which implements the CreatureFactory Interface. This interface has one method

```
public Scrubbable getCreature(PApplet p)
```
This method returns your animal, i.e. the root of the animal. This is the method where you will create/construct the Animal object. A class implementing this interface should not have any contructor.

Build an iterator.

For the createIterator() function from the Scrubbable interface, you need to create an Iterator that iterates through the structure of your creature.

Create the iterator for your class. It must do an InOrder traversal of the structure your creature. This iterator has all the information it needs to do a traversal of your creature's structure.
Since it implements Java's Iterator interface, you must implement
1. ```
boolean hasNext()
```
  this returns true if there is more animal parts left, else false
2. ```
Object next()
```
  this returns the next item in the traversal. To fit with Java's specification, you should cast the next item to Object. The client of the iterator can cast it to your parent class.
3. ```
void remove()
```
  just create a stub for this method.

Code Requirements:

A base class
2 subclasses that extend the base class
Provide an interface for saving the drawn animal as an image.
User interaction with the mouse and/or keyboard lays down your animal on the drawing area, and allows animal editing
Add controlP5 controls to select body parts, to clear the screen, etc.
All your classes should be within the package iat265.[sfu_username]. For example, if your sfu email is aga53@sfu.ca, all your code should be within the package iat265.aga53

You can use our code:

You can use our solution to Assignment 2 to build your animal.

Tips and Tricks

Design everything first and then implement the code.
Implement one object at a time. Test often! Systematic design can save you time.
Code a SINGLE item (maybe even a single line) then TEST TEST TEST
Style counts! We want to see some amazing designs!