IMGD 3000 Project 2 Dragonfly Due dates: A: Dragonfly Egg: September 13, 11:59pm B: Dragonfly Naiad: September 20, 11:59pm C: Dragonfly: September 28, 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).

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:

• Starting and stopping gracefully
• Logging messages to file
  • With flexibility in arguments
• Adding and removing of game objects
  • Providing 2d game world positions for game objects
• Running game loop with:
  • Fixed update rate (e.g., 30 Hz)
  • Step event sent to all game objects each loop step

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):

• Manager (base class)
  • Startup and shutdown
• LogManager
  • Singleton
  • Startup and shutdown
  • Flexible means of writing data (integers, strings, ...)
• Clock
  • Milliseconds of resolution for timing
• Position
  • (x,y) location
• Object (base class)
  • Position
  • Type
  • ID
• ObjectList
  • Store 1+ Objects
  • Add/remove Object
• ObjectListIterator
  • Iterate through ObjectList
• GameManger
  • Singleton
  • Startup and shutdown
  • Game loop
  • Send step event to all Objects each loop
• WorldManager
  • Singleton
  • Store all game objects
  • Add/remove game objects
  • Provide list of all game objects
  • Support deferred, batch removal of game objects (markForDelete)
• Event (base class)
  • Getting/setting type
• EventStep
  • Getting/setting type

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.

2B - Dragonfly Naiad

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

• Output
  • Support drawing 2d (ASCII) characters
  • Clean refresh each game loop
  • Support color
• Input
  • Accept non-blocking keyboard and mouse input
  • Send as event to all game objects
• Object Control
  • Support "velocity" for game objects with automatic updates
• Collisions
  • Detect between any two solid game objects
    • Provide "solid" attribute for Objects
  • Send as event to both objects
• Misc
  • Provide "altitude" attribute for Objects for layered drawing
  • Send "out of bounds" event when Objects off screen

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, non-audio version of Saucer Shoot called 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):

• Manager (base class)
  • Add support for sending events (onEvent)
• GameManager
  • Modify game loop
    • Get input (InputManager)
    • Have objects draw themselves (WorldManager)
    • Refresh screen (GraphicsManager)
• GraphicsManager
  • Singleton
  • Startup and shutdown
  • Draw character at (x,y) with and without color
  • Draw string at (x,y) with and without color, with justifications
  • Detect and store horizontal and vertical screen boundaries
  • SwapBuffers to refresh display to latest world image
• InputManager
  • Singleton
  • Startup and shutdown
  • Support keyboard and mouse input
• WorldManager
  • Support boundary limits (equal to screen limits)
  • Detect collisions
  • Move objects
    • Modify update to support velocities
    • If out of bounds, provide event
    • If solid, provide collisions (detection and event generation)
  • Draw method, where all objects draw themselves
    • Support altitude, where lowest objects drawn first
• Object
  • Getting/setting Solidness (hard, soft, or spectral)
  • Getting/setting Altitude
  • Getting/setting x-velocity, y-velocity
• EventOut
  • Getting/setting type
• EventCollision
  • Getting/setting type
  • Getting/setting both objects in collision
  • Getting/setting collision position
• EventMouse
  • Getting/setting type
  • Getting/setting mouse action (button)
  • Getting/setting (x,y) location on screen
• EventKeyboard
  • Getting/setting type
  • Getting/setting key pressed

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.

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:

• Sprites
  • Provide multi-character frame
  • Provide for animation and animation "slowdown"
• Audio
  • Provide support for sound effects
  • Provide support for music
• Object
  • Associate Sprite with Object
  • Draw frames in sequence to achieve animation
  • Support "slowdown" of animation
• Resource management
  • Read and parse sprite data from file
  • Provide Sprite access for Object
  • Load sound effect from file
  • Provide Sound access for Object
  • Associate music with file
  • Provide Music access for Object
• Bounding boxes
  • Provide for game objects larger than single character (for movement and collisions)
  • Bounding box based on Sprite size
• Camera control
  • Game world larger than screen (viewport)
  • View port movement around game world
• View Objects
  • Support for "heads-up display" objects that don't interact with game world
  • Objects have integer values that can be updated (delta or new value)

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 a working Project 2c should support a slightly reduced version called Saucer Shoot - Dragonfly:

• git repository
• zip

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

• ResourceManager
  • Singleton
  • Startup and shutdown
  • Load Sprites, Sounds and Music from files
  • Find Sprites, Sounds and Music with given labels
• Sprite
  • Width, height
  • Label
  • Color
  • Frame count and frame
• Sound
  • SFML sound
  • SFML buffer
  • Label
• Music
  • SFML music
  • Label
• Frame
  • Width, height
  • Data
• Box
  • Corner, position
• Object
  • Support Sprites
    • Centered
    • Animation rate (slowdown)
  • Getting/setting bounding box
    • Centered based on Sprite
• ViewObject (derived from Object)
  • Getting/setting location
  • Getting/setting border, color and display string
  • Getting/setting value
  • Event handler to handle EventViews
• EventView (derived from Event)
  • Getting/setting tag
  • Getting/setting value
  • Getting/setting delta
• WorldManager
  • Modify collision detection for box intersection
  • Add camera (viewport) control
    • Get/set view
    • Translate world (x,y) to view (x,y)
  • Modify to support adding/removing View Objects
  • Modify update to support View Objects

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.

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 or Mac provides the necessary support for graphics (SFML) to complete your game engine. In general, your Project 2 implementation can be done in any development environment as long as:

• Your coding is done in C++
• SFML is supported
• The TA can compile and run your engine

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.

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

    mkdir lastname-proj2a
    cp * lastname-proj2a  /* copy all the files you want to submit */
    zip -r proj2a-lastname.zip lastname-proj2a  /* compress */

https://ia.wpi.edu/imgd3000/

Use your WPI username and password for access. Visit:

Tools → File Submission

Select "Project 2a" (or "2b" or "2c", as appropriate) from the dropdown and then "Browse" and select your assignment (proj2a-lastname.zip).

If successful, you should see a line similar to:

 Creator    Upload Time             File Name        Size    Status   Removal
 Claypool 2015-09-26 23:40207  proj2a-claypool.zip  4208 KB  On Time  Delete

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).