koenhendriks / carparksimulation Goto Github PK

The current simulator program only implements the payment of normal tickets. We need to implement the payment for parking pass holders. This will involve adding a new class for the parking pass customers which will have its own implementation of the payment. Parking pass holders do not need to go to the payment machines, but can use their cards at the exits.

Add this as a seperate chapter.

After #5 we need to make another UML diagram

There are going to be different types of payment so we need to make an interface for the pay-methods.

Use all the chapters from the log book and implement them in the presentation. Also look at the report content to possibly add some chapters to the presentation.

We need to add an extra view to the application that will output information as text. This new view should provide vital statistics for the management. In it you should display:

• The current revenue for this day
• The expected revenue for customers who are still in the garage and haven’t paid yet.

We need to make use of the AbstractView structure that can be found in the Life Project.

It might be useful for later if we write some documentation for our current source code. This way we don't have to do this later, and we will establish some code clarity.

We need a view that shows the length of the in- and out-going queues of the parking lot.

Make sure to update the Language class to keep all the String objects in one place.

We need a Class where we can get certain strings from a string code. This way its easy to change strings without going through all the code.

For example,

closeMessage should represent "Are you sure you want to close the application?"

As is, the license information is linked with the customer class. We want to link this to the car class.

Add this to our Github project.

Ask your lectures how you should hand in the code (dropbox, git access, paper). The code shall be evaluated on the following points:

1. Correctness;
2. Appropriate use of language constructions;
3. Style (comments, indentation, naming of variables;
4. Technical level and functionality;
5. Originality and creativity;
6. Correct use of MVC-pattern;
7. Logical package structure;
8. Has Javadoc been added at the right places. (Generate the HTML pages that provide the Javadoc documentation).

We should evaluate our code to see if it holds up to these requirements.

The Car Park View needs to be refactored to be used in the MVC package

The existing project needs to be refactored to a MVC application.

Projects to look at

To help understand the MVC structure we can look at the following projects:

• MVCDynamicModelThread

• MVCDynamicModelThreadGeneralized

  These are the same examples only in this case the MVC-like aspects of the program have been put in abstract superclasses where possible

• Life

  A simulation program that uses almost the same MVC-like abstract superclasses. This project also contains two controllers (on purpose) to show how flexible MVC can be.

The MVC study files can be downloaded here

Car parking is saved in a 3 dimension deep array at the current state (See here) .

To check if a car is parked at a certain location we need to loop trough all the floors, rows and places. This is incrementing resourceful when the cark park gets populated.

We need to store the location and the cars in a different mater.

To test / debug our application, we'll need to develop a simple GUI with buttons that allows us to run the program for 1 or for 100 steps.

Note: We shouldn't put to much time this this GUI because we'll be updating it with a MVC later in the weeks.

We need to implement a view that can distinguish the different types of cars that are parked in the garage.

A legend can describe the objects on the screen towards the user.

Don't waste to much time on this, because we have to implement the reservation system of the BITM student later.

This is the 'business' part of our project. Describe in a way as we are making this report for the project owner.

This view is needed to control the simulation and give the user input.

Maybe we should create a new class Counter that extends the Car Park Model. In here we should count all the cars and statistics so our car park model stays clean with car park business logic.

It might be nice to implement a menu bar, so the user doesn't have to exit the application by closing the window.

We could add a File menu to implement these menu items:

• Reset (allows user to restart simulation);
• Exit (allows user to exit without closing window);

Another possibility would be for us to implement a Help menu to implement this item:

• About...

We make the fourth chapter for the log book, describing what are the differences between the different MVC designs that we found on Blackboard.

InteliJ should be running for all team members with version control enabled and set up correctly. The code needs to be able to run from a main method in the Simulation class.

We need to make an UML class diagram before we refactor the application to MVC as seen in #5

We have to draw an UML sequence diagram describing one step of our project.

We a more clear description of this project for the repository readme. It should be clear what this project does and why.

For example we can at certain occupation levels or queue lengths.

Refactor the classes from the original code to the new MVC structure.

We need an extra statistics view that represents that data in a different way, for example with histograms or line graphs.

Maybe take a look at JFreeChart ?

We need to add a class for customers who made reservations.

The implementation of the pay-method will be different for different kinds of customers. So we'll need an interface for the payment. See #11

Add this to chapter 5 in the report.

As the project is the delivered (the as-­is) the simulation is not really easy to expand or
maintain. This is why we are working on this simulation to make it easier to add cars, to
maintain the amount of cars that are entering the car park and to have a control over the parking spaces, rows, floors and cars.

Keep track of the time and days the carpark is running.

The application keeps running in the background if you close the window. It would be nice if the proces gets terminated if you close the Jframe

We wil have to start our final report in the first week.
The first two chapters:

Problem definition

In this chapter you will describe the problem that you are trying to solve with this application. Try to formulate your problem in a generic and realistic way. Expand on the use of simulations in business problems.

Analysis of as-is situation.

Make an analysis of the program as it is. Which are the problems, how can it be improved, which functionality does the product owner require? Questions to be asked are for example:

• If I run the program several times, do I get the same results?
• Is there a general pattern in the results?
• Is the simulation easy to expand/maintain? Which are the limitations?
• What can you find on internet on this kind of optimisation problems?

Complete these first two chapters and send them to you tutor to be checked.

Keeping track of time is done in a really obsolete way. This should be refactored preferably with a Time class that acts as the main Time model.