11 Prove : Assessment Guidelines
Overview
This document outlines the guidelines for instructors and teaching assistants to use as they assess the assignment. It is intended to give structure and guidance to the grading process to ensure that the most important components of the assignment are highlighted, and to promote consistency across sections.
In all cases, the instructor has the latitude to deviate from this rubric on a case-by-base basis to provide the holistic assessment that, in their judgment, best matches the assignment.
Fundamental Concepts
This assignment is designed to highlight the following fundamental concepts:
Inheritance
Polymorphism
Correct use of composition (HAS-A) relationships
Scoring
The following categories are used to score this assignment:
/15 - Functionality: Ship /15 - Functionality: Bullets /15 - Functionality: Rocks (Collisions) /15 - Design: Inheritance /13 - Design: Polymorphism / Virtual Functions /10 - Code: Cohesion of classes/methods /10 - Code: Style /7 - Functionality: Above and beyond core requirements ------------ /100 - Total
Overall Scoring
For each of the categories the following general scoring guidelines apply:
100% - Correctly implemented
85% - Minor error exists
70% - A major error or multiple minor errors exist
50% - A good attempt was made.
0% - No attempt made.
If necessary, scores in between the above classifications can be assigned.
Things to look for:
Functionality: Ship
Turning independent of moving
Thrusting takes into account direction and current velocity
Functionality: Bullets
Accounts for both ship direction and velocity (start moving up, turn to the side, fire a bullet, should be going diagonally)
Should die after a certain amount of frames
Functionality: Rocks (Collisions)
Should spin at different rates for different sizes
Rocks should correctly break apart
Can be hit by bullets and a ship
Design: Inheritance
Everything that can be in a base class is (Wrapping, points, alive, velocity, advance, etc.)
Good use of inheritance in the Rock classes, not duplicating things unnecessarily
Design: Polymorphism / Virtual Functions
Advance should be overridden by bullet to handle time to live
Advance should be overridden by rocks to handle the spinning
They should call the base class advance (super().advance()) and then do other things. If they have duplicated the advance logic again in the derived classes, this is just a minor error, but something we should point out.
Draw should be an abstract method in base classes and overridden (but only minor error if it is not done, but we should see at least one abstract method somewhere...)
The next two are the most important part of this line item:
Use of virtual functions in the rock classes to handle breaking apart.
Make sure in the game class they are using polymorphism for the breaking up of rocks. We don't want to see things like "if rock.getType() == big, then create two new rocks" It should just say "rock.breakApart()" or "kill()" or something, and then let the virtual function handle it.
Code: Cohesion of classes/methods
Short concise methods that do one thing well. Some of the collision detection can be a little involved, but if it's pages upon pages, it should be improved
Code: Style
Good variables, indentation, etc.
A comment here or there in the program is expected
Function headers
Functionality: Above and beyond core requirements
2 minor, or 1 major