Not Quite Paradise

Possibly, one day, a roguelike.

Badges

Current position:

Quality of last commit:

Quality of repo:

Table of Contents

• Playing NQP
• Motivation and Intent
• Design Goals
• NQP Roadmap
• NQP Philosophies
• Dependencies
• Documentation
• Contributing
• License

Playing NQP

Until there is a build in place if you want to play you'll need to download the Not Quite Paradise repository and, with Python installed, enter the following into your terminal.

pip install pygame tcod snecs pygame-gui pytweening scipy
python -m {Not Quite Paradise's download location}/scripts

To avoid any confusion, make sure to replace {Not Quite Paradise's download location} with the filepath to wherever you saved your Not Quite Paradise download.

Motivation and Intent

To create a fast, dynamic, combat-focused, traditional roguelike where the environment, enemies and even the gods all respond to your actions.

To support this Not Quite Paradise is split into two sections; the engine, aimed at being flexible and usable for other projects, and the game, that creates the specific use-cases and rules for the gameplay. Eventually these sections will be separated entirely but for now, to simplify development, they are held together.

Design Goals & Pillars

Like a lot of people who attempt to make a game I ended up creating an engine. As it's grown so to has the ethos behind it. That ethos is usability first, readability second and performance third. Of course it should be performant, but in this case a friendly user experience is more important.

The design pillars that the NQP engine are as follows:

• Data Driven Design - entities and maps are built using external data held in json files. Skills use external data for their values but currently require some internal code to be created.
• Procedural - maps are created procedurally.
• Extensible - base classes for all core actions are provided in the engine.
• Composable - built with an entity component system, all entities are expressed by their attached components.
• Explicit - using mypy and consistent naming all methods, functions and classes have a clear purpose.
• Interaction-focused - the interaction system is in place and is easily extensible. As new content is added the interactions

In progress:

• Configurable - control remapping is in place ready for controller support, as are the foundations for accessibility and player configuration of their game.

NQP Roadmap

Following advice from a knowledgeable sage, for the time being this project is focused on getting a solid primary game loop in place abd then achieving an MVP. That is to say that the aim is to achieve a basic level of functionality and a core set of features on which to build.

All planned features and known issues are held on the NQP Issue Tracker.

NQP Philosophies

For NQP, the game, the design is underpinned by the following philosophies:

• Flow - Periods of impetus to ensure the player is driven forward appropriately. Periods of openness to allow self pacing, reflection and exploration.
• Coherent - Information pertinent to the player is always made available and easy to parse, utilising a mix of art and text. Avoid need for external resource use e.g. a wiki.
• Flexible - Never a best way, always a different one. The only limitations in place should be those that drive diversity of play.
• Accessible - Supports different kinds of players, e.g. can use keyboard, mouse or controller interchangeably, with minimal difference in experience. e.g. Colour scheme is colour-blind aware.
• Customisable - Near-core game settings can be influenced or set by the player allowing for extensive personalisation.

Dependencies

The NQP engine has several dependencies, while most of these will be removed over time as the engine is optimised I wanted to call out a few special ones that will always be included.

• snecs is a blazing fast, super-simple to use ECS.
• python-tcod is a staple of every python roguelike out there and provides performant field of view, line of sight and pathfinding operations.
• pygame-gui is an accessible, flexible gui library.
• pygame is an SDL wrapper and provides input handling and rendering.

Documentation

See the project's Github Pages for a full suite of documentation.

Contributing

See the Developer Guide for details on how you can get involved.

License

MIT