[Dragonfly]

IMGD 3000 Project 2

Dragonfly

Due dates:

  • A: Dragonfly Egg: September 15, 11:59pm
  • B: Dragonfly Naiad: September 22, 11:59pm
  • C: Dragonfly: September 30 (was September 29), 11:59pm

    NOTE! For project 2c, instead of implementing the final Dragonfly features, you have the option of improving your Dragonfly Egg or Dragonfly Naiad and re-submitting. Your revised grade will replace your previous grade. For planning, Project 2a (Dragonfly Egg) and Project 2b (Dragonfly Naiad) are worth a combined 85% of your total Project 2 grade. If you are taking this option, still use "proj2c" for turnin, but state clearly in the README that this is a resubmission and indicate for which project (i.e., Project 2a or Project 2b).


Top | 2A - Dragonfly Egg | 2B - Dragonfly Naiad | 2C - Dragonfly | Resources | Submission | Grading

The goal of this project is to build your own 2d, text-based game engine, called Dragonfly. Once done, you will use your Dragonfly to design and develop a game from scratch (in Project 3).

Project 2 is broken into three smaller parts, called A) Dragonfly Egg, B) Dragonfly Naiad and C) Dragonfly, that build upon each other to end up with a fully functional, full featured game engine. Since it is critical that your engine code be easily understood (from the game programmer's perspective) and, more importantly, robust, the three projects are structured such that completing parts A and B will provide for a fully functional, if somewhat limited, game engine. This will enable you to proceed with Project 3. Thus, the due dates are staggered so that most of the time is allocated for part A and part B, but there is still time for completing part C, if you are able. In addition, completing part B will be sufficient for earning a "B" grade for Project 2. Fully completing part C will result in additional features for the game engine and provides the opportunity for earning an "A" grade for Project 2.

Important! It is much better have tested, trusted, robust code that only implements parts A and B than it is to have buggy, partially implemented code that attempts to get into part C.

You will work alone for this project. This will ensure you have the development skills needed even if your tasks in Project 3 (making your own game, where you do work in teams) are more partitioned. While you can discuss the project with other students and even help each other debug code, you must write all code yourself.


2A - Dragonfly Egg

Part A of the assignment is to construct a game engine (in C++) that provides the following capabilities:

No visual depiction of the game is required for part A. Instead, all output is via printing to the screen or, better, to a logfile via the LogManager.

Classes to be implemented, with some of the features each has, include (note, below list not necessarily in order of implementation):

The functionality described above is obtained through careful implementation of the indicated classes. An approximate breakdown of point values as they apply to Part A is below.

Grading Guidelines
LogManager 20%
Clock 10%
Position 5%
GameManger 10%
Object 10%
ObjectList 10%
ObjectListIterator 10%
Manager 5%
WorldManager 15%
Event and EventStep 5%

2B - Dragonfly Naiad

Part B of the assignment is to continue construction of your game engine using your codebase from Part A, adding the following additional capabilities:

All of the above capabilities must be thoroughly tested, bug-free and ready for a game programmer to make a game (you, in project 3)!

In the meantime, you might test out your Dragonfly Naiad with a non-sprite-based version of Saucer Shoot, Saucer Shoot Naiad: git repository, zip).

Classes that will be implemented and/or extended from Part A include (note, list not necessarily in order of implementation):

  • EventOut
  • EventCollision
  • EventMouse
  • EventKeyboard

    The functionality described above will be obtained through careful implementation and/or modification of the indicated classes. An approximate breakdown of their point values as they apply to Part B is below.

    Grading Guidelines
    Manger5%
    GameManager5%
    GraphicsManager20%
    InputManager20%
    WorldManager20%
    Object and Events10%
    Testing (all classes/functionality)20%

    2C - Dragonfly

    Part C of the assignment is to continue construction of your game engine using your codebase from Parts A and B adding the following additional capabilities:

    All of the above capabilities must be thoroughly tested, bug-free and ready for a game programmer to make a game (you, in project 3)!

    If you implement all the above features, you might test out your Dragonfly with the tutorial game, Saucer Shoot. The final version of the game has a few of the optional engine features, but Saucer Shoot, version 9 should be supported by a working Project 2c.

    Classes that will be implemented and/or extended from Parts A and B include (note, list not necessarily in order of implementation):

    The functionality described above will be obtained through careful implementation and/or modification of the indicated classes. An approximate breakdown of their point values as they apply to Part C is below.

    Grading Guidelines
    Interest management (note: no longer needed for 2c!)
    Sprite animation25%
    Box collisions20%
    Views10%
    Resource manager20%
    View objects and events15%
    Random numbers5%
    Documentation, ease of running and grading5%

    Note, in addition to the above breakdown, up to 20% points can be lost if testing, and/or documentation surrounding how to run tests, is missing, incomplete or insufficient.


    Resources

    Development in Linux, Windows (Cygwin) or MacOS provides the necessary support for graphics (curses) to complete your game engine. In general, your Project 2 implementation can be done in any development environment as long as:

    If you have doubts about any of the above, ask before heavily investing time in your development environment.

    Important! You must adhere to the class design as provided by the Dragonfly book. Not only will following this design provide a path towards a complete engine, but it will also allow us to use automated scripts to test the functionality of your engine. Failure to follow this design will mean your engine fails these tests and your grade will suffer. However, adding additional functionality beyond what is described in class is possible.

    Refer to the Dragonfly documentation for details on the classes you will implement for your game engine.

    See the Dragonfly book and the class materials for technical details on game engine implementation.


    Submission

    Your assignment is to be submitted electronically via turnin by 11:59pm on the day due. You must hand in the following:

    If you do not have your files on the CCC machines, then copy your entire working directory to your CCC account. Then, login to the CCC machines (using slogin or putty). Use tar with gzip to archive your files. For example (adjust the below instructions for 2b and 2c, as appropriate):

        mkdir lastname-proj2a
        cp * lastname-proj2a  /* copy all the files you want to submit */
        tar czvf proj2a-lastname.tgz lastname-proj2a  /* compress */
    
    Submit your assignment (proj2a-lastname.tgz):
        /cs/bin/turnin submit imgd3000 proj2a proj2a-lastname.tgz
    

    Following this, you should verify that your files have been entered into turnin by executing the following command:

        /cs/bin/turnin verify imgd3000 proj2a
    

    If you need more information, see Using the `turnin' Program for additional help with turnin.


    Grading Rubric

    Below is a general grading rubric:

    100-90. The submission clearly exceeds requirements. The functionality is fully implemented and is provided in a robust, bug-free fashion. Full functionality is clearly depicted in one more more samples of game/test code and through clearly provided logfile messages. Documentation is thorough and clear.

    89-80. The submission meets requirements. The basic functionality is implemented and runs as expected without any critical bugs. Functionality is depicted in one more more samples of game/test code and through logfile messages. Documentation is adequate.

    79-70. The submission barely meets requirements. Functionality is mostly implemented, but may not be fully implemented and/or may not run as expected. There may be a few bugs, none critical. The functionality is depicted in sample game/test code, but full representation is not shown. Documentation is inadequate, missing key details needed to understand the engine and/or to build the programs.

    69-60. The project fails to meet requirements in some places. The game engine is missing critical functionality and/or what is there has bugs. The engine may crash occasionally. Game/test code demonstrating the engine is missing or incomplete. Documentation is inadequate, missing key details needed to understand the engine and/or to build the programs.

    59-0. The project does not meet core requirements. The engine cannot compile, crashes consistently, or is lacking many functional features. The sample game/test code is missing or incomplete. Documentation is woefully inadequate or missing.


    Top | 2A - Dragonfly Egg | 2B - Dragonfly Naiad | 2C - Dragonfly | Resources | Submission | Grading

    Return to the IMGD 3000 Home Page

    Post questions to the Dragonfly question-answer forum or send them to the staff mailing list (imgd3000-staff at cs.wpi.edu).