rubatopy / rubato

A lightweight, developer-first game engine built for Python

     

rubato is a modern 2D engine for game developement in python built in Cython using SDL2. It is aimed to aid in rapid prototyping and educational development of games as a stepping stone towards AAA tools such as Unity. rubato is more robust than its competitors, with a more intuitive syntax, high customizability, and zippy performance.

Here are some features we're especially proud of:

• Powerful Rigidbody Physics
• Event Subscription/Listener System
• Spritesheets and Animations
• Particle Systems
• Tiled / Tilemap Support
• Multichannel Sound System
• Antialiasing + Anisotropic Filtering
• Collision Optimization with Quadtrees
• Texture-based Hardware Acceleration
• User Interface Elements
• And more!

1.0 is the latest API-stable release as of Dec. 31 2022, and we plan to maintain backwards compatibility in future releases. Please note that the alpha versions (0.x.x) are now deprecated and it is strongly recommended to update in order to get the latest features and optimizations.

Wondering about the name? rubato is a music term that indicates a phrase that should be performed expressively and freely. We aim to harness that same freedom, bringing a fresh, modern take on game developement in python to a variety of users regardless of their coding background.

Getting Started

Using rubato is super easy. Just install rubato through pip in a terminal:

pip install rubato

After that, getting a window up takes only 3 lines of code!

import rubato as rb

# initialize rubato
rb.init()

# launch the window
rb.begin()

Check out our tutorial to learn more about what you can do with rubato.

Changelog

See CHANGELOG.md

Looking to contribute to rubato?

See CONTRIBUTING.md. And join our discord!

A big thank you to all of our contributors who help make this project possible.

Code of Conduct

See CODE_OF_CONDUCT.md.

rubato's Issues

Add a sound manager

UPPERCASE lowercase shift and caps switch.

When shift and or CAPS is pressed make

rb.game.radio.listen("p_down", callback)
and
rb.game.radio.listen("P_down", callback)

be different.

Also
if rb.Input.is_pressed("r"):
and
if rb.Input.is_pressed("R"):

Go through everything and make sure documentation is up to date

Describe the issue
The docs are really outdated and need some updating.

Document the default configs

add 1 line explanations to each element

Automatically do collisions for every hitbox in a scene

Perlin Noise clean up

Make sure that it is implemented correctly, giving the right credit.
Should be clean and utilize hidden classes so that the user can only use the Perlin noise function.

SAT point-of-contact calculations

split custom window methods and properties from Game into Display

as the title says, we want to access window information and properties not through Game (which is super cluttered and not following OOP) but through the Display class. This means porting all the current Game window methods into Display and refactoring code to work with these new changes.

Preferably we could also have separate getters and setters for the window size and the display width/height so that users don't have to mess with unintuitive sounding variables like "resolution".

Scaling bad

Martin fix scaling

Restructure API Documentation

Make sure that everything can be deleted properly

Make some examples

Describe the issue
These are basically just big code blocks that demo how to use certain things

Add versioning

Describe the issue
Add versioning to the documentation using: https://sphinxcontrib-versioning.readthedocs.io/en/latest/

Create functions wrappers for renderer in Display

Create wrapper for all functions here that we think a user might need without looking into SDL documentation.

DrawPoint
DrawLine
etc.

Write a proper changelog

window resize event is not propagated

re-work readme and library abstracts

Animations need to not be tied to fps

Describe the bug
Currently animations are running very quickly at higher fps

Expected behavior
Instead, they should be independent of the games fps

Additional context
What would be nice is if you define a running fps for each animation you create (for example, 24fps for one animation and 60fps for another and the animation would move at that speed (as long as the value is not greater than the current fps or something).

correct angular momentum compensation

Frame based time and convert to heapqueue

https://docs.python.org/3/library/heapq.html
Use the following link to use heapqueues.
They are better suited to our timer system where we don't need lookups.
Also, implement frame-based time so that we can call things in x frames from now.

Need a Getting started tutorial

Describe the issue
We need a proper getting started page.

Documentation link
https://tinmarr.github.io/rubato/dev/intro.html

Check required components and auto add them if needed

make rectangle draw functionality not be polygon-esque

it's super inefficient to have rects draw as polygons; we should make them draw like normal rectangles instead.

Add direction to in Vector

create helper function allowing to import an entire folder of spritesheets

Basically create a function that takes in a directory with spritesheet images, and import them all, adding them to an animation component automatically such that each filename (with extension removed) becomes the name for that respective animationstate.
i.e.:
I have a folder with idle.png and run.png, each of which is a spritesheet in which the individual sprites are the same size.
I run "import_from_folder(folder_dir)" and it imports all of the spritesheets into an animation object with the names "idle" and "run".

SAT Circles

Do circles

Set position right... topright...

like pygame rect functionalities.

Animations need to load from sprite sheets

Sound system is really bad

Just needs to be rewritten from scratch

Create tileable image component.

• Simple Tilemap
• Tiled Support
  • Proper scaling
  • Multiple Tilesets
  • Layer Offset
  • Multiple Layers
    • Tile Layers
    • Object Layers
    • Group Layers
    • Image Layers
  • Layer Visibility
  • Layer Opacity
  • Tile Opacity
  • Objects Collisions
  • Map Background Color
  • Parallax
  • Worlds
  • Layer tint color
  • Tile animations

Tiled strict limitations:

• No infinite maps
• Orthogonal and rectangular tiles only

Fix zoom, things don't render in

make the "redirecting you to the latest doc" page nicer

make it fit the css theme somewhat, or at the very least not just a blank html page with paragraph text.

Make text and button be part of the complete menu system

dependant on #38

Have some sort of naming system for scenes, groups, sprites, and components to make errors easier to understand.

Currently errors tell you WHAT the problem is but not WHERE the problem is. To solve this a naming system should be implemented. For example, we could use the variable name as the sprite name (handled when the sprite is added to a group). Same thing for groups. Components could just use their type name since there is only 1 component of each time on a given sprite.

Make custom clock system

The pygame one is kinda bad

Menu System

A proper menu system would make it much easier to make proper games

Document Rigidbody

The attributes need documentation

Properly document utils folder

proper rectangle hitbox

Image rotation

Rotate images around their centre nicely using this.
(https://stackoverflow.com/questions/4183208/how-do-i-rotate-an-image-around-its-center-using-pygame)

Pausing doesn't work

Describe the bug
When you set the game state to paused, the game quits instead of pausing.

Expected behavior
The game should pause

Non alpha numeric keys are poorly referenced in the radio keydown event

For example, the space key is " ". Instead it should match pygame's key nameing

Random functions shouldn't be in files alone

Come on yamm be better

Move merge_params out of sprite to a hidden utils file

When we will use options in other directories apart from the sprite directory we will need to use the merge_params, and we don't want to import sprite.

Combo input function

Just like there is functionality for ctrl+z and ctrl+shift+z etc. We need to be able to give the combo functionality to users. rb.Input.is_combo_pressed(*args).

modifier key is considered pressed when it isnt

how to replicate:
run the ball pit, and resize the window by holding shift. release shift BEFORE releasing the mouse cursor to end the resize operation. Now if you press "a" the secret combo will print even when shift is not pressed.

could be a mac only issue, could also be an SDL issue and therefore unfixable, not sure so assigning to martin.

better colors

add some more natural default colors
sauce

Change coordinate system

Make it so that the 0,0 coordinate is the center the screen instead of top left being 0,0.

Also make it so that positive Y is pointing upwards.

Add perlin noise function

In math. Like unity

Various game parameters don't update live

For example:

• Changing the window name variable doesn't change the window name

There are many others.

What I want to happen is if a variable is "public" than changing it needs to have an effect. If you want it to be just read only, use a property method. If the user of the library shouldn't need to change it make it "private" (add a dunder).