SWE 2410, Lab 3: Designing a Garden

This assignment spans multiple labs. You will do just the initial design and write just a bare minimum of code for this lab. A more complete implementation will be required for the next lab. Both lab assignments will be done in teams of two (with teams of three as needed).

You have been asked to build a garden simulator for a botanist. In this simulator, bees visit flowers for food and flowers can drain energy. The garden will be shown from above with bees moving through the flower bed; there is no need to show how tall the flowers are. The intent is to deliver a system that the botanist could extend to support wider varieties of flowers and bees. This project will give you experience with identifying a problem domain and using this to build an implementation.

Requirements

This section specifies the full requirements for your project. You will implement only a portion of these for this lab, but implement the rest for the next lab.

Your system must be a JavaFX application. The windows must be at most 700 pixels high and 1000 pixels wide. These limits ensure faculty can grade your solutions on school laptops at default resolutions.
- Be sure the application terminates cleanly when the user clicks the close form icon.
You will implement various types of bees that move in specific patterns. Each bee moves forward one step for each “tick” of time. You can think of a tick as a particular number of seconds, but the precise duration does not matter. In your simulation, pressing the right arrow key moves the simulation forward one tick. It is required this be the right arrow key; having some students use other keys makes grading hard.
Bees are to move a programmer-specified distance each tick. Select a distance, such as 10 pixels, that allows bees to move reasonably quickly across the screen but not so fast that key behavior is unobservable.
Bees will land on simulated flowers whenever they pass within a certain distance of the flower. Use Euclidean distance $\sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2}$ between the (approximate) centers of objects to determine how close a bee is to a flower, and assume a bee always lands on a flower if it the distance between the two of them is less than a quarter of the bee’s image width. The goal is that bees and flowers should interact only if they touch.
Bees have an energy level that decreases on each move. Bees should start at an energy level that would allow them to cross the screen multiple times if they lose one or two points on each move. If a bee reaches 0 energy, it dies and is removed from the screen. In the final implementation, all bees must eventually die.
The simulation will have a flower bed containing at least two types of flowers: one that provides a given number of units of energy (in the form of nectar) and one that drains energy from visitors. This behavior must change over time for at least one of the types of flowers; for example, you could have a type of flower ignore every other visitor or change how much nectar a flower gives. If a flower drains a bee of its energy, it will die.
Include at least two types of bees, with multiple instances of each.
- One of the bees must pick a flower at random and then move towards that flower. The bee will then move towards the flower until it reaches it, then a new flower is picked. Do not implement this as a bee that just moves randomly; no bee would move in that way. The logic of having a target flower that changes is important to the assignment. Allow this bee to encounter flowers along the way to the target (as described in the distance calculation above).
- Another bee must have a different pattern such as flying straight to a flower, moving back and forth across the screen (covering the full garden), a spiral, or large zig zags. Again, random movement is not interesting; follow some reasonable pattern. This bee must not target a specific flower; it must simply follow a pattern.

Each bee must have a simple, distinct graphic along with a graphical and numerical display of its energy level. Display the energy level in two ways: as a number (which must be appropriately sized and colored to so as to be clearly visible) and as a health bar (a line showing how close the bee is to dying). The health information must be on the screen near to its bee and it must move with the bee. As in the checkers lab, all of the graphics related to a moving component can be maintained in the same class. The class can maintain each component individually or use a JavaFX Pane class (such as VBox in the provided sample code - see below). Talk to your instructor if you are unsure how to implement this.
When the program starts up, display 10 flowers and 5 bees. Provide a way for the user to adjust the number of bees and flowers in the garden so they can experiment with different population mixes. When there are very few flowers relative to the bees, the bees should die quickly. When there are many flowers, the bees should live a long time. It is expected that there would be support for up to dozens of bees and dozens of flowers of different types.
Flowers must also have simple, distinct graphics. In the cases of flowers that change their behavior over time, provide some type of graphic to indicate the status. It could be a simple +/- symbol, a countdown timer, or some other indicator showing the flower’s status. Do not include a health bar for flowers since they do not die.
A collection of JPEG images is being provided; you can use these for your bees and flowers or you can provide your own. In any case, you must have a window (or a part of a window) that has a legend showing which behaviors go with which flower and bee graphics. We need this for grading.

Process and design constraints

Your solution must include at least one interface or abstract class that the team writes.
You are not required to apply any design patterns, but you can if you wish. Be cautious, however; adding a design pattern involves more code, and this lab already has a number of complex elements. If you add a pattern, make sure you have at least one class that refers to that pattern; for example, FlowerBehavior or BeeMoveStrategy.
The above requirements give some flexibility on how bees and flowers behave. You can implement alternatives, but they must have behaviors that are at least as complex as the behavior described here. For example, the random movement bee tracks the target flower so that the flower does not change until the bee arrives. Do not include a “user-guided” bee; the goal is to encapsulate how different types of bees move, not to create a search-and-destroy game.
Each group member is expected to complete a fair share of the work in both labs. Each group member needs to check in interfaces to their classes early in the project, and each must complete an initial version of their portion before the next lab session. Failing to complete your portion will make it difficult for us to assign you to groups in future labs, making it difficult for you to satisfy course outcomes. An important part of this is to push your work to the shared git repository on a regular basis. Do not wait until the due date to start committing and pushing your work!
Document each file with who wrote that file. That person “owns” the file; others should not change it, with the possible exception of the JavaFX controller class.
Assuming all team members are contributing, all team members will receive the same grade on the lab. This means it is important that all members review the work to make sure all requirements are satisfied. Instructors do reserve the right to assign different grades to each member of a team when necessary.
The distributed code uses the package name garden and has the start class Main.java. Do not change this. In addition, do not change the locations of the .jpg files; these locations must be consistent for grading.

Lab 3 Submission

As discussed above, you do not have to implement the full set of requirements for this lab. Instead, submit the following:

A single PDF that includes all of the following:
1. The full names (first and last) of all people in your group.
2. A domain-level class diagram as defined by the domain-level UML Standards document. Draw this diagram in Enterprise Architect unless your instructor allows another method. Be sure to include either attributes or methods (or both) for every class, and be sure that all classes are associated with at least one other. Review a draft of diagram with your instructor by the end of the lab period to ensure you have the correct elements and structure. Warning: JavaFX elements such as controllers and menus are not domain classes! For this lab, domain classes capture objects that (say) a botanist would know about.
3. One of your bees targets a random flower and moves in a direct line to that flower. Draw a sequence diagram capturing the user clicks on the right arrow to have the bee execute one step to reach a targeted flower, interact with that flower, select a new flower, and then have the user click right arrow again so the bee executes one step towards the new flower. For the purposes of the diagram, assume the garden has just one bee and two flowers. Remember that the items at the top of the sequence diagram are objects, not classes; be sure to name each object. See the EA resource page for directions to create a sequence diagram.

An initial version of the system that builds using IntelliJ in a Git repository. At a minimum, your initial version must create a JavaFX form, display at least one bee, display at least one flower, and move the bee to the right on each keypress.
- Include stubs for each class in the domain diagram. A stub class has just the name and includes implements and extends declarations.
- Document who will implement each of the stubs as a comment in the file.
- Give the responsibility for each class in the respective file. Capture things like having to track particular information, move in a particular way, or capturing a particular behavior. As an example, the responsibility of a checkers piece in lab 1 might be “to track the position of the piece and to determine what moves are legal.”
- Be sure to check in the full project, including both the src and .idea folders but not .idea/workspace.xml or .class files. Be sure you have the standard, global gitignore file on your machine. If everything is checked in correctly, your instructor and teammate(s) will be able to open the project in IntelliJ without setting any additional configuration. Ask if you need help!
- Be sure any code you intend your instructor to grade is on the main branch. Using branches on a small project like this is not very useful.
- Do not use Enterprise Architect (EA) to auto-generate stubs. EA will add useless information that you have to delete.
- You do not have to implement collisions for this lab.

Your instructor may publish additional submission requirements.

The final, more complete implementation will be due as next week’s lab.

Support Files

garden_jpgs.zip: Images you can use for your flowers and bees.
bee_simulator.zip: sample code illustrating placing an image on a panel and using arrow keys to move it around. In most cases, this is the code already given to you in the starter repository.
Your solution will differ from this in many ways, but key ones include capturing the location in domain level objects (rather than having “free floating” variables like beeXLocation) and you will use the arrow key to move forward in the simulation rather than direct objects.

Frequent Issues

When I try to run the program I get a message like “Module javafx.controls not found.” This likely means you need to update the VM Options in the run configuration to match the path to your installed copy of JavaFX.