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

Going to use MKDocs to hook into readthedocs.

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.

Each method needs a docstring and the class itself.

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.

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.

See the init of physics.Physics for pattern.

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.

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.

  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

Copy from ppb_vector or write a new one.

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

Break up the exception handling.

Replace the **kwargs with keyword only arguments.

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

Probably a problem in SDL.

There is no menu system.

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

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.

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

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

Probably too big as a single task. Low priority.

Figure out the best way to provide a save system.

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

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

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.

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.

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