• So-far, we've explored concepts like physics, algorithms, components, and pathfinding in Unity.
• Now it's time to start putting to the pieces together into a project.
• This is the summative assessment for the CSE2110: Procedural Programming 1 module.

How it Works:

• The project outline can be found in the Free Learning Unit (this page) and the Project Rubric.
• This project is broken down into 3 steps:
• Design: Create a flowchart for your algorithm.
• Build: Code your elevator system.
• Test: Test and refine your algorithm.

Assessment:

• You'll receive a 1-7 grade and comment for each step in the project.
• From those grades, you'll receive an overall 1-7 grade for this project.
• These grades and feedback will be shared via the project rubric.
• The overall grade will be entered into the Gibbon markbook.
• Be sure to read the Project Rubric so you're familiar with how this project will be graded.

• Your challenge in this project is:
  
  
  You have just been hired as a junior elevator programmer. The company's current elevator code is slow and buggy. Your first task is to design a new algorithm for their elevator system. To do this, you'll use Unity 3D to create a simulation of an elevator to test and demonstrate the algorithm you create.
  
  
• Your company is using an Agile development practice. They have given you the requirements of the elevator as a set of four User Stories
• User stories are short, simple descriptions of a feature told from the perspective of the person who desires the new capability, usually a user or customer of the system.
• Take a moment to read each of the stories so you understand your design parameters:

User Story 1:

• As a building manager, I want an elevator system that can manage at least two elevator shafts.

User Story 2:

• As a person waiting for an elevator, I want to see which floor it is on so that I know it is coming to pick me up.

User Story 3:

• As a person using the elevator, I want to be able to decide which direction to go so that I can go up or down.

User Story 4:

• As a person waiting for an elevator, I want it to stop and pick me up if it is going past my floor.

• Consider how you would build your algorithm to meet these requirements.

• Before diving right in and coding your elevator system, you need to design the algorithm.
• Remember: an algorithm is basically a set of steps and procedures to follow.
• To design your algorithm for this project, you'll be creating a flowchart.
• How do you make a flowchart? You have many options:

• 
  https://creately.com/creately-start

• 
  https://miro.com/signup/
  
• Or, you can also use your favourite graphics program.

• When creating your algorithm flowchart, start with:
• The sources of input (a button press?)
• Consider the processing steps (what decisions does the system need to make?)
• Add branches for the different output (does a car begin to move? if so, where?)
• Try to decompose your algorithm into small steps: think of each symbol on your flowchart as a method call.
• For example, rather than a complex step called "move elevator", you might need smaller steps for "is elevator already moving?", "get closest car", "get distance between floors"

• Using Unity, setup a simulation for your elevator algorithm.
• As a simulation, the code and the algorithm are the most important part. Your elevator system does not need need to be complex:
• You do not necessarily need a player controller; the camera can be fixed.
• You don't need buttons inside the elevator car.
• You don't need any fancy graphics or 3D models.

• There are many ways to test a piece of code.
• For this project, we're going to use a method called Acceptance Testing.
• Acceptance Testing is a level of software testing where a system is tested for acceptability.
• The purpose of this test is to evaluate the system’s compliance with the business requirements and assess whether it is acceptable for delivery.
• For your hypothetical career as an elevator programmer: Would your boss accept your solution?

• Look back at the User Stories described in the project overview.
• Ask yourself: Would this user accept my elevator algorithm as a solution to their problem?
• User Story 1: Does my system manage at least two elevator shafts?
• User Story 2: Can my users see which floor the elevator is on?
• User Story 3: Do my elevators allow users to go up or down?
• User Story 4: Will my system stop and pick up passengers along the way?

• There are many other types of software testing, such as unit testing, end-to-end testing, and usability testing.
• We're using acceptance testing to ensure we've met the needs in our user stories.
• Once you've tested your elevator against each of these user stories, you're ready to submit!

• Once you've designed, built and tested your elevator system, please:
• Save your Unity project.
• Zip the folder containing your project.
• Add your name to the filename.
• Upload it to Google Drive.
• Create a Google Doc for your project submission:
• Add your name and a brief description of your project.
• Include any instructions for how to run your elevator simulation.
• Include an image or link to your algorithm flow chart in your submission.
• Include a link to your Google Drive file (double-check sharing settings).
• Submit your doc through the Elevator Challenge on Google Classroom.
• Also submit a link to your doc to complete this unit in Free Learning.