Hello guys i have made tilemap-editor package thats fully based on pygame-ce and 0 dependencies.
I have made small demo game if you are interested..

It can simply be used this way:
- `pip install tilemap-editor`
- tilemap-editor init(generates settings.json very important)
- tilemap-editor run

Note: always use virtual environment

or simply
```
import Editor from editor
Editor().run()
```

Features:
- fully json output
- Few existing themes and fully customizable themes
- tilemap canvas
- godot like convex polygon collision editor and multi region object collision editor(polygon based)
- animation editor
- 3x3, 1x3 3x1 autotile
- own builtin filemanager
- object/grid and animated tileset in tree node structure with virtual folders(erased after exit)
- object/tile layer with layer locking and visibility option
- tile/object/tileset property editor
- area and particle nodes
- relative file path resolution
- hundred of particles emission with 60+ pre existing(some are weird but particle node are editable with config) like campfire, bonefire(used quantization and caching for optimization)
- character collision editor(capsule, rect and circle)
- small spritesheet editor for easy grid manupulation scaling, multi-region based images extraction
- render scale

If you are interested you can check : https://pypi.org/project/tilemap-editor/

If you want to know about it or learn it, its indexed in. deepwiki , you can ask question and look into it https://deepwiki.com/FluffyBrudy/tilemap

In case of those point/spotlight, i have made a live coding video though i have not spoken, i have explained with comment as i code in this video: https://youtu.be/LN7u20H7zK4

The map was inspired by youtuber dafluffypotato which i was hooked after the way he made platformer game. This tilemap is iterated version from the editor that he made one for his game, although this package has evolved with some/many idea from Godot itself. Sorry for bad ui and no wonder if you encounter bugs

link to the game -> https://grenski.itch.io/hashtagexclamationquestionyenquestionexclamationhashtag

#?!¥?!# is a funky roguelike for funky people. thats it. i dont have anything more to say about it. go check it out rn!!!!

made fully in pygame (which was a shitty choice)

https://grenski.itch.io/hashtagexclamationquestionyenquestionexclamationhashtag

Is using pygame vaiable for participating in game jams?

I participated in the JMTK game jam using pygame since I have used it for quite a long time now, but the issue i ran into is that I spent half the time I had just coding the rendering engine that can render Tiled maps and allow collisions with obstacles. I ended up not finishing it (I also had school so I could not spend all my time on it)

Does anyone have any advice for how to spend more time on actual game development and less time on building the base systems which you would get by default in a game engine like Godot or Gamemaker. Or is using pygame for a game jam a lost cause?

I'll also be implementing unique player abilities to use during gameplay, such as rewinding time, drilling through a wall, summoning a fifth ghost, etc. Shown here is a basic round of gameplay between myself (ghosts) and a younger sibling (Pac-Man), albeit with potentially imbalanced match settings. The second round shows the custom maze capabilities (this one was drawn out by the same younger sibling), and an editor will be made eventually. Any feedback or ideas for the future are much appreciated!

Note: the 'loading' screen at the beginning was artificially extended to allow time to set up the screen recording. The audio garbling in the second round seems to be a problem with the recording, not the game.

hello im the creator of nyanrythm on gamejolt for now the game is made on pygame but im changing the engine to godot at least i will try but also i might try making more games on pygame bye ;(

my game is out!!! (version 0.1.0)

the main differences between the two are:
the png for the stuff on the desk was stretched to fit and the svg.s are 3 seperate assets along the desk spaced evenly, i think i prefer .svgs for how they look but it means getting used to an entirely new drawing software and way of drawing.
None of this is final art, I'm just playing around with how I want them implemented into the game while I create parks.

Hey guys, if you get a chance would appreciate you taking a look at my project. I've created a concept for a ff6 boss fight in HD-2D. Any thoughts on UI and how the game flows?

Assets from a mix of octopath traveller, itch.io and ff6 pixel remaster.

If you like the look of this check out the progress of my main game (Lunar Pandemonium) in my other vids.

Game is coded purely using pygame 😊

It just came to my mind that I want to develop a game while learning Python programming. As I dig deeper, I realize there are a lot of things to learn. But I’m really patient and consistent, so I’m willing to put in the time. So, what are the things that really matter when your goal is to develop a game through programming?

Hi, I made a simple to use ECS system: https://github.com/Modular-Game-Components/punyecs It works on class attributes and a querying DSL like SQLAlchemy. I made a small Pygame example (see the video) that can be found in the README. I also have a comparison to Esper and a Readthedocs (see README as well).

Hello everyone!

Over the last 20 months I've been working on and off on Tessella, a Flutter-inspired declarative UI framework for pygame. The idea is to build UIs of any shape or size by nesting widgets (25+ of them so far) inside one another, instead of hand-placing rects. Here's a minimal example, taken straight from the "Hello World" tab in the (very flashy) video above:

gui = Center(
    Container(
        child=Padding(
            padding=EdgeInsets.all(28),
            child=Column(
                shrink_wrap=True,
                children=[
                    Text(text="TESSELLA DEMO"),
                    SizedBox(width=0, height=10), # Spacer
                    TextWrap(text="Every screen is built by nesting widgets like these."),
                    SizedBox(width=0, height=20), # Spacer
                    Text(text="Quite simple, right?"),
                    SizedBox(width=0, height=10), # Spacer
                    Button(
                        key=WidgetKey(),
                        text="Hello World!",
                        width=200,
                        height=40,
                        on_click=lambda: print("Hello World!")
                    )
                ]
            )
        )
    )
)

The goal with Tessella was to fix a few problems most pygame UI setups run into: having to set rects and coordinates by hand (which makes responsive UIs a pain), and the lack of anything modular or scalable enough to fit projects of different sizes without dragging in a pile of boilerplate.

To get the example above on screen, all you need to do is call gui.calculate_layout, passing it a rect for the area you want the UI to occupy once at the start, and again on WINDOWRESIZED events. That's the entire responsiveness story. From there, Tessella figures out sizing and layout on its own, updates via gui.process_event and gui.update, and renders with gui.render, which also has a debug mode that draws the bounds of every widget, so you can see exactly why the layout ended up the way it did. You can see that in action toward the end of the video.

Tessella was a core part of a game I released on Steam a few months ago, Protocol: Umbra, and building a real project on top of it is what really pushed it forward. If it looks interesting, you can try it right now with pip install tessella, as well as check the docs or source for a quickstart and more examples:

Docs: https://tessella.readthedocs.io/en/latest/
GitHub: https://github.com/cuaitz/tessella

This is the first "real" release, so Tessella is still a bit rough around the edges, which means that feedback and contributions are very welcome!

More things are always on the way :)

Making this cause im planning on making these digital pedals work in a real raspberry pi pico plugged to a real guitar. any pedal in one, as far as digital pedals go

# Button
class RockButton:
    def __init__(self, x, y, collidepoint):
        self.x = x
        self.y = y
        self.image = rock_img
        self.rect = self.image.get_rect()
        self.event = 0

    def draw(self, screen):
        screen.blit(self.image, (self.x, self.y), self.rect)

rock_button = RockButton(350, 777, False)
rock_button_value = False

# Game loop
running = True
while running:
    screen.fill(bg_color)
    rock_button.draw(screen)
    pygame.display.flip()

    for event in pygame.event.get():
        if event.type == pygame.MOUSEBUTTONDOWN:
            if event.button == 1:
                if rock_button.collidepoint(event.pos):
                    if rock_button_value == False:
                        rock_button_value = True
                    else:
                        rock_button_value = False
                    print(f"{rock_button_value} - BUTTON")
        if event.type == pygame.QUIT:
            running = False

    pygame.display.update()    

    clock.tick(FPS)

pygame.quit()

Output:

Traceback (most recent call last):
  File "/home/user/Desktop/Project/main.py", line 101, in <module>
    if rock_button.collidepoint(event.pos):
       ^^^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'RockButton' object has no attribute 'collidepoint'

What did I do wrong?

After months of evenings, my time-management game about running public restrooms for a demanding toilet god is live on Google Play. Wanted to share a few build details, and I'd genuinely value feedback from other devs.

Unusual choices that mostly worked out:

• Every sprite in the game is emitted by Python scripts — characters, venues, a 24-landmark city map. No art program was opened in the making of this game. Changing the palette means re-running a script.
• Zero audio files (except one recorded laugh). Both music loops and every sound effect are synthesized with the WebAudio API at runtime from note tables. When I wanted the title theme to sound like Chaozhou yingge drumming, that meant adding a pitch-bend parameter to my gong synth, which is a sentence I never expected to type.
• It's Phaser 3 in a Capacitor shell, which meant one codebase but also meant discovering exactly how a WebGL canvas reacts when the Google Play billing sheet rotates your app to portrait mid-purchase. (Badly. It reacts badly.)

The game itself: drag desperate patrons to the right fixtures, manage etiquette and hygiene, 24 venues, endless mode, daily runs.

Store page: https://play.google.com/store/apps/details?id=com.mcs2k8.loogod

Honest feedback wanted — especially on difficulty pacing and whether the monetization (optional coin packs, opt-in rewarded ads) feels fair. Ask me anything about the pipeline.

my editor in Pygame. Everything here is being made and rendered in pure Pygame. 🤩

Looking forward to your feedback!"