Should Inherit Publisher and keep a reference to the view and controller interfaces.

See the init of physics.Physics for pattern.

BaseClass.change() currently returns (self.running, {"next_scene": None}) which causes an error when the engine attempts to call None during activate.

• Write a test to cover this case. Expectation: Engine should not call if "scene_class" is uncallable.
• Resolve the failing test.

instead of leaving rendering code to the developer, the Engine should use a Scene.game_objects attribute to get a list of sprites, then filter the list by checking for collision against a Scene.viewport attribute.

Scene.game_objects: Iterable[GameObject]
Scene.viewport: GameObject

The goal of this change is to simplify the drawing code and being able to centralize optimizations of rendering routines.

Will require some refactoring to BaseSprite.

Remove the constants TOP, BOTTOM, LEFT, and RIGHT and combine them with the side definitions inside of Side as the Enum Members.

A Pygame based subsystem to create PPB Mouse events.

• Listens for hardware mouse events
• Raises ppb.events.Mouse events
• Translates screen space to game space.
• Extends Update event

All sprites are two pieces: A model and a view. The view is based on the hardware rendering objects. The model is a class that listens for events from the engine and manages state.

The name field should be wrapped in quotation marks in the representation.

It's built to handle the event of an empty queue, but also catches an empty scene stack.

Break up the exception handling.

Plan a configuration layer to reduce necessity of using kwargs everywhere.

Should return parent, side inside the displayed representation, not value, parent.

Each method needs a docstring and the class itself.

Reported by two windows on Windows platforms, all sprites blink erratically during game play.

Probably a problem in SDL.

Probably too big as a single task. Low priority.

Logic is currently backwards, scene_stop should be scene_running and the logic should be
if not scene_running:
scenes.pop()

• Add test
• Fix interface

On macOS when passing flags=pygame.FULLSCREEN to GameEngine the now fullscreen window does not have a close button, and without a keyboard escape can not be closed.

Proposed: Implement some form of keyboard value that will kill all PPB windows either by throwing a QUIT event or exiting the engine loop.

Right now, it is impossible to add debug logging to the Engine itself at the logging.DEBUG level without it flooding a user's debug logging.

To prevent this, some sort of mechanism should be added to allow engine logging to use a level lower than the built in logging.DEBUG

To that end, a new logger class could be implemented.

Alternatively we can monkey-patch logging to have an additional method.

Or finally we could, as developers on the engine proper, use the "hard" way of calling logging.log(NEW_LEVEL, debug_message) directly.

Additionally, we should pick a logging value to use.

Combine the Model, Mobile, and Conrollable into a single GameObject class.

Components will be the items that are used to make a game (As separated by the items that make the engine run.)

Components: Sprites and in game objects.
Utilities: View, Controller, Publisher and similar.

Currently the engine subscribes to itself to catch events, by subscribing to each scene in turn we can have only a single publisher active at a time.

Right now, when one system needed another system, there's no good way to do it.

As part of this issue, we should build an interface to allow this.

Considerations:

• Should be non-blocking: A system that doesn't have another system shouldn't lock up and should do its best to keep functioning without the other system.
• Should probably use the existing signalling system to request and respond.
• Consider a simple callback model.

Replace the **kwargs with keyword only arguments.

  File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ppb/scenes.py", line 31, in simulate
    for group in self.groups.values():
RuntimeError: dictionary changed size during iteration

• Write test
• Resolve

There is no menu system.

Right now, the flags parameter accepts a single flag, which must conform to the bitwise-OR flags from SDL/PyGame. Would much prefer that flags parameter accept either a single flag or an iterable of flags that will be combined for the user inside the engine.

• Define PPB Flags for supported flags.
• Consider that flags is an artifact of implementation and really is talking about rendering flags.
• Accept either a single flag or an iter of flags that can be bitwise-ORed inside the engine itself.
• Make lazy evaluation.

Place holder for me.

Going to use MKDocs to hook into readthedocs.

Copy from ppb_vector or write a new one.

Figure out the best way to provide a save system.