RPG is a 2d role-playing game. Currently in development. Core developer goals for this project are to:

1. Explore game dev in Python (e.g. using Pyglet and PyGame)
2. Explore UI (e.g. using PyQt5) and low-level graphics (e.g. using OpenGL, PyOpenGL) libraries
3. Integrate python with low-level compiled code (e.g. C)
4. Use best practices in Python packaging (e.g. adhering to PyPA, using setuptools)
5. Use best development practices in CI/CD solutions and documentation (e.g. Flake8, PyTest, Tox, Travis CI, Github Actions, ReadTheDocs)
6. Use best practices in OOP Design Patterns.

1. Python Game Dev

   • coders legacy pygame Simple RPG tut
   • wiki.python game programming in python
   • wiki.python game libraries
   • wiki.python python games

2. UI & Graphics

   • wiki.python pyqt5 tuts
   • pyqt5 docs
   • openGL docs

3. Python Bindings

   • Cython docs
   • RealPython on bindings

4. Python Packaging

   • A short, practical guide to using setuptools
   • Python Packing Authority (PyPA) docs
   • setuptools docs

5. CI/CD and Documentation

   • Pep8
   • Flake8 docs
   • PyTest docs
   • Tox docs
   • ReadTheDocs docs
   • Travis CI docs
   • Github Action docs

6. OOP

   • GoF's Design Patterns

   • Design Patterns:

     • (Creational) Abstract Factory*; Factory Method*; Prototype
     • (Structural) Composite*; Decorator*; Facade; Flyweight
     • (Behavioral) State*; Chain of Responsibility; Command; Observer; Visitor; Mediator; Visitor; Strategy; Interpreter

   • Classes:

     • Class constructor methods & dependency injection
     • Designing subclass constructors from superclass constructors
     • Composition (interface) inheritance vs. implementation inheritance
     • Multiple inheritance & mix-ins
     • Enumeration classes
     • Importing classes
     • Class destructor methods
     • Types:
       • Abstract
       • AllowedSubclasses
       • ConstructOnLoad
       • Inferior classes (for overloaded graphics functions)
       • Sealed

   • Fields:

     • Constant properties
     • Dynamic (Instance) Properties
     • Static Data
     • Property get/set methods
     • Property events/listeners ('event.proplistener')
     • Types:
       • AbortSet
       • Abstract
       • Access
       • GetAccess
       • SetAccess
       • Constant
       • Dependent
       • GetObservable
       • SetObservable
       • Hidden
       • NonCopyable
       • Transient

   • Events (& Listeners):

     • Trigger events for listeners both tied and untethered to event source ('notify')
     • Determine if any listeners currently exist for event ('event.haslistener')
     • Deactivate and reactivate listeners
     • Pass extra event data to a listener callback ('notify(obj, 'evt', evtdata)) by subclassing 'event.EventData' and adding a new property to that subclass
     • Execute listeners in a specific order
     • Have a listener recursively trigger the same event (via the 'Recursive' property of a listener object) - (but make sure the listener callback changes the object data in some way such that infinite recursion does not occur)
     • Save and restore a listener
     • Types:
       • Hidden
       • ListenAccess
       • NotifyAccess

   • Extras:

     • Save and load process for objects
     • Property initialization order dependency
     • Class introspection and metadata
     • Class arrays and class hierarchical heterogeneous arrays

• docs\: documentation and examples and development guidelines
• rpg\: game source code
• tests\: unit and integration tests
• changelog.md: an up-to-date changelog describing latest features and their commits
• env.yml: dependencies file for conda
• pyproject.toml: specifies build tools
• requirements.txt: dependencies file for pip and setuptools
• setup.py: configures and packages the source code
• tox.ini: tox file for running tests on package installs across environments

• Clone this repo and install package in editable mode:
• Using semantic versioning
• Contributing:
  • see project organization and style guidelines
  • All work should be done on feature branches. All work should be flaked and include tests. PRs from feature branches should be sent to dev. On a new release, dev is merged into main. CI runs on dev and main.
  • On any merges into dev, the following should be updated (as necessary):
    1. readme.md
    2. docs\
    3. root directory config files
    4. changelog.md
  • Github Issues and Projects should be used to track and organize development.