Complete the implementations of these classes

By
Responsive Centered Red Button

Need Help with this Question or something similar to this? We got you! Just fill out the order form (follow the link below), and your paper will be assigned to an expert to help you ASAP.

Order Form

# Requirements
For Part I of the Objectgericht Programmeren project, you shall complete the implementations of these classes, in accordance with the provided documentation and the above requirements and clarifications, such that a working (simplified) Breakout game is obtained. You shall ensure that these classes are properly encapsulated.
You shall also insert complete public and internal formal documentation for these classes.
You shall also write a test suite for these classes that tests all of the code you wrote, except for code that runs only in cases where the client performed an invalid method call or an invalid constructor call.
The solution you submit for Part I counts for 4 out of the 20 points for the project.
# Minimum requirements
To obtain 2 out of 4 points for Part I, the following conditions must be met:
– The code you submit must compile without errors when compiled with FSC4J (i.e. there must be no errors reported in Eclipse’s Problems view for this program, after installing the FSC4J plugin).
– You did not make any changes to the provided code; you only added the requested missing implementations and documentation.
– It must include a test suite that tests the correctness of all of the code you wrote, and there must be no test failures or errors when running your project with JUnit in an installation of Eclipse that has the FSC4J plugin installed.
– The constructor(s) of `BreakoutState` must apply defensive programming to deal with invalid parameters.
Constructors of `BallState`, `BlockState` and `PaddleState`  must apply contractual programming to deal with invalid parameters.
– Your code must pass our own (secret) test suite.
– It must be clear from the formal documentation you write that you have a basic understanding of how to properly document single-object abstractions.
When you submit your solution, an automatic check will be performed that checks some of these requirements (including compiling your code and running both your test suite and our own test suite, in the presence of FSC4J).
If the check fails, you will have an opportunity to submit a corrected solution, provided the submission deadline has not yet passed.
The automated tests that we perform are far from complete and it is important that you also implement an additional test suite of your own, to validate all the intended behavior of your code.
Detailed submission instructions and the automatic check will be available by Friday, 11 March 2022, 16h00.
# Extra requirements
To obtain 3 out of 4 points for Part I, additionally, your implementation and your test suite must be complete and correct, and your formal documentation must be reasonably complete as regards @throws, @post, @invar, @immutable, and @representationObject clauses.
Additionally, you must not duplicate code for detecting collisions between (1) balls and blocks, (2) balls and paddles and (3) balls and walls, by introducing and using a new well-documented abstraction for representing rectangles.
Your solution must implement all the requirements
Furthermore, `BreakoutState` must have an invariant that specifies that the paddle is located entirely within the game field and this invariant must be enforced correctly.
To obtain 4 out of 4 points, additionally, your formal documentation must be complete and correct, not just with respect to the tags mentioned above, but with respect to the other tags used in the course as well (including @inspects and @mutates).
Additionally, `BreakoutState` must have invariants that specify that all blocks and balls are located entirely within the game field and these invariants must be enforced correctly.
# Errata
(Thanks to Machteld Vanderborght, Louanne Theys & Anna Proost, Robbe Serry and Arne Van Damme, Wenzel Sleurs)
* Variable `topRight` in the method `GameMap.createStateFromDescription(String description)` should be called `bottomRight`, as it refers to the bottom right point of the field.
The size of the pitch can be derived from this variable’s value, since the top left point of the field is the origin (i.e. coordinates (0,0)).
* A comment in the method `GameMap.createBall(Point bottomLeft)` mentions “initial speed `initSpeed`”.
That comment should instead refer to “initial velocity `INIT_BALL_VELOCITY`”.
Note that we should have used the term velocity because this vector defines both the initial direction and the initial speed of the ball.
* The arguments called `bottomLeft` in the methods `GameMap.createBall`, `GameMap.createBlock` and `GameMap.createPaddle` should all be called `topLeft`.
# Errata about previous versions of this project assignment (now fixed)
* In the sentence “To avoid weird effects, it is important that a ball only bounces on an object when the direction from the ball (vector d) to that object is at a blunt angle from the ball’s current velocity (vector v).”, the word blunt should be sharp.
In the subsequent sentence “You can check this easily by verifying that the dot product of the two vectors (d . b) is positive.”, the formula (d . b) should be (d . v).
* There was a contradiction between the text “You shall deal with invalid constructor or method calls defensively.” and the later requirement “The constructor(s) of `BreakoutState` must apply defensive programming to deal with invalid parameters. Constructors of `BallState`, `BlockState` and `PaddleState`  must apply contractual programming to deal with invalid parameters.”.
We have removed the former sentence, i.e. constructors of `BallState`, `BlockState` and `PaddleState`  must apply contractual programming.
* The formula for mirroring a vector over a direction had mysteriously disappeared from the previous version of this text.

How to create Testimonial Carousel using Bootstrap5

Clients' Reviews about Our Services