Operation Outrageous Overhaul

Leges Motus

Operation Outrageous Overhaul (or oOo for short, and Operation Overly Outrageous Overhaul of Object Orientation Organization for long) is the current endeavor for Leges Motus to be a better-organized project, and an easier project to extend. Beginning after the release of 0.4.0, this will be the main focus of the project for 0.5.0. It will be a long road, but the more we put it off, the worse it'll be.

oOo is a large revamp of the client to bring it up to snuff with a more thought-out design. The original client is plagued by being too integrated in such a way that made it difficult to modularize, and as such difficult to write different frontends, and just generally difficult to work with. oOo hopes to alleviate this, but it is a difficult process, given the existing code.

As this is essentially a rewrite of most of Leges Motus, there is much organization that must be kept sorted. A current TODO list can be found here, which will hopefully be up-to-date, and contain relevant links to tickets.

Remember, Leges Motus is open-source, and you are welcome to help!

Current Status

Armed and dangerous.

Playability: Playable! (Though with difficulty, since visual feedback has a long way to go).

Plan of attack

As oOo will be huge, the work is broken down into multiple stages.

1. Implement new graphics engine (DONE)

   The old graphics engine is slow, and could use a good rewrite. There were some design problems, and a lot of things could use work

   1. A baseline drawing context type for drawing primitives without making calls directly (DONE)
   2. SDL-independent Image struct that holds tex pointers or the actual data (DONE)
   3. Caching of Images (DONE)
   4. Various thin Graphic classes (DONE)
   5. Bones for manipulating Graphics without having a large hierarchy of the graphics themselves (DONE)

2. Rewrite game engine (IN PROGRESS)

   Note that a lot of this has to be done in lock-step with the graphical game engine so that things can be tested effectively

   1. Get a baseline GraphicalPlayer class working (DONE)
   2. Get visual scaling to screen size working (DONE)
   3. Fake some basic map loading (DONE)
   4. Implement some basic physics to bounce around on the map (DONE)
   5. Fake some basic networking (DONE)
   6. Implement key-bindings (DONE)
   7. Get jumping working (DONE)
   8. Implement most networking (IN PROGRESS)
   9. Implement gate lowering (DONE)
   10. Implement single weapon and freezing - (DONE) - Weaponry Design
   11. Implement remaining physics (DONE)
   12. Implement real map loading (IN PROGRESS)
       1. Hazards (DONE)
       2. Spawn Points (NOTHING TO DO?)
       3. Repulsion (DONE)
       4. Force Fields (DONE)
       5. Implement object sets (DELAYED)
   13. Implement remaining weapons (DONE)
       1. Penetration (DONE)
       2. Spread (DONE)
       3. Thaw (DONE)
       4. Area (DONE)
       5. Charge(?)
   14. Implement heavyweight server (DONE)
       1. Fix weapon firing (DONE)
       2. Fix map loading to not destroy the MapReader as it loads
       3. Change packets to make heavy server receive input about when/where to jump/shoot (DONE)
       4. Improve packet design to avoid including useless information in player updates from client/server. (DONE)
       5. Fix player died packet sending. (DONE)
   15. Add last minor gameplay features:
       1. Health regeneration (DONE)
       2. Server-to-client map sending support.

3. Rewrite graphical extensions to game engine (e.g. menus, fancy effects) (IN PROGRESS)

   1. Implement widgets (IN PROGRESS)
      1. Implement buttons
      2. Implement progress bars (DONE)
      3. Implement text input
   2. Redo HUD (IN PROGRESS)
   3. Redo menu
   4. Overhaul configuration file format
   5. Write gamepad support
   6. Write customizable key-bindings
   7. Redo animation protocol
   8. Special effects
      1. Particle effects
      2. Shaders (IN PROGRESS)
   9. Redo audio engine
   10. Redo sound effects

Note that some of the later parts may get pushed back to 0.6.0.

Tips and Tricks

Some bits of the refactor are tricky and may include things like conflicting naming. Here are some relevant tricks:

• These two classes have the same name, and thus I can't compile!

In the new class .hpp, #define ClassName NewClassName and make sure everything that needs it #includes the .hpp instead of forward declaring. Once the old version gets axed after the refactor is done, remove the #define, and it should be fine. This is no longer necessary! The only old client class still being compiled is client/Curve. If you are still running into a double-name problem, please make clean. For a list of these in Leges Motus, please see the TODO list.