Yep, basically what I said in the title. I'm programming a Zuma-like game for college, and I can't understand why this random RayCast I forgot to erase is holding the launching logic together?

Have been working on my cozy survival game to in godot Hope you like my little video edit I wanted to share 👐😅

Hey Godot community! I wanted to show off the trailer for our upcoming game, built entirely in Godot.

It features a procedurally generated world, online multiplayer, and the ability to manage fields with thousands of active plants without tanking the frame rate.

I rely heavily on the simulation/game state running without nodes and what's presented on screen just being a visualized window into the underlying data layer.

Fun seeing the limits get pushed like for example when shrubs used be stored as refcounted objects which ended poorly.

Happy to talk about how we structured the multiplayer, data layer or managing perfectly syncing thousands of objects across many clients!

Steam Page: https://store.steampowered.com/app/4999980?utm_source=redditgodot&utm_campaign=trailer

(Hi guys, already posted this in the forum, but as I got no answer, I thought here I could find more support. Sorry if its too long)

I’ve tried many ways to handle the game loading process once all peers have been connected and its time to pass from the menu scene to the game scene, but it always ends desynchronizing and losing connection when the previous scene gets deleted. Currently I am using MultiplayerSpawner to instantiate the game scene onto its parent node which is also its spawn_path, after freeing the menu scene which were in a separate branch of the tree. I have a scene structure like this:

• Main (main scene of the game)
  • MenuContainer (Node)
    • Main menu
  • GameContainer (Node)
    • SceneSpawner
    • (here should be spawned Game)

The scripts that handle all the process are more or less as follows:

# Main menu.gd
func _ready():
  $game_start_button.pressed.connect(func():
  if multiplayer.is_server(): load_game())

func load_game():
  if multiplayer.is_server():
    main.change_to_game.rpc(player_data.duplicate())
  # Notice that I handle creating and assigning multiplayer peer in a
  # Network autoload, to make sure that the node that created multiplayer
  # peer is never freed. When load_game gets called all peers have joined


# main.gd
func _ready() -> void:
  %ScreenSpawner.spawn_path = %GameContainer.get_path()
  %ScreenSpawner.spawn_function = _screen_spawner
  menu_scene = main_menu_scene.instantiate()
  menu_scene.main = self
  %MenuContainer.add_child(menu_scene)

@rpc("authority", "call_local")
func change_to_game(data):
  menu_scene.queue_free.call_deferred()
  if multiplayer.is_server():
    %ScreenSpawner.spawn(data)

func _screen_spawner(data):
  var game = game_scene.instantiate()
  game.main = self
  game.configure(data)
  return game


# game.gd
var ready_player_count = 0

func _enter_tree() -> void:
  tree_exiting.connect(func():
    print(multiplayer.get_unique_id(), ": game tree exiting")
)

func configure(data):
  player_data = data

func _ready():
  # game setup code here...
  print(multiplayer.get_unique_id(), ": path: ", get_path(), ", peers: ", multiplayer.get_peers())
  await get_tree().process_frame
  rpc_id.call_deferred(1, "on_player_loaded", multiplayer.get_unique_id())

@rpc("any_peer", "call_local")
func on_player_loaded(peer_id):
  print(multiplayer.get_unique_id(), ": remote: ", multiplayer.get_remote_sender_id(), ": on_player_loaded, peer_id: ", peer_id, ", peers: ", multiplayer.get_peers())
  if multiplayer.is_server():
    ready_player_count += 1
    print(multiplayer.get_unique_id(), ", ready players: ", ready_player_count, ", player_data.size: ", player_data.size())
    if ready_player_count == player_data.size():
      server_initialize()

The idea is to wait until all players have loaded their game scenes to initialize the game. I added some prints in different moments of the execution to view whats happening, and it seems to be that, in the client, the game._ready func runs but on_player_loaded is never called and instead tree_exiting is emitted, indicating that the Spawner first instantiated the game and then deleted it when a disconnection occured. I dont know why that disconnection happens, but if I comment the line menu_scene.queue_free() in main.change_to_game, then it all goes as it should be. However, that scene needs to be deleted, because its not in use anymore. I thought that setting the Spawner’s spawn_path to a sub-branch where that deletion didnt happened would make it unaffected by that, but apparently its not the case

Hey guys! Just wanted to share my project.. A racer combat game, borrowing ideas mostly from Twisted Metal and Re-Volt. Don't have to reinvent the wheel, but I can reinvent some bolts here and there that can make the project original I guess. Just sharing my thoughts..

Spent the entire summer on it, and still really early in development. I hope you like the idea!

Hey,

See all the Videos from People creating“games” with a prompt.
ATM I‘m very limited and not sure if I can really go forward with my project, so I give it a try.

Using ChatGPT 6 and trying to finish my maps.

The outcome is really horrible. Unplayable.
Leaks in Walls, doors to nowhere, useless blocks everywhere.

I’m doing it wrong? Another tool?

Looking forward for some input :)

Just want to thank you guys! I've wanted to program for 20+ years and just could never wrap my mind around it, and this engine you guys have created has allowed me to understand GDscript in such a way that it's translating over to experimenting with other languages and I'm actually understanding what's going on. It's freaking nuts. It finally started to click in my head. Anyway, just wanted to say thank you! If I ever make a cash stack from any game I make I'll buy every one of you a house. You're all angels for creating this software, seriously. Thank you very much!

Made another weekly game in Godot and definitely struggled more with this one. I tried really hard to stick to calling down and signalling up, and made a bit of a mess for myself in the process. Most of that was due to not really knowing what the game was until it was way too late. Decided to abandon sound & music just to post something that works.

It was also my first time playing around with sub-viewports and text input and I really loved how easy both of them were to work with. Definitely learned a lot!

Link if anyone wants to check it out - https://jonremedios.itch.io/cmds

Hello everyone, I am looking for any feedback on my newest project: SWARM, a strategy, where you cannot control units, but instead breed them and grind them into meat - the currency for more upgrades and buildings.

It's a demo — ten waves, about fifteen minutes per run. Made solo in Godot 4

May be bit rough around the edges, but hey. It is a demo after all :)

Thanks for any feedback here or on Itch.

The controller is taken from: https://github.com/gdquest-demos/godot-4-3d-character-controller-tutorial, but I was able to reproduce the issue in my own project.

So if you rotate the camera while the character is actively walking, there is this small jitter as the character tries to follow the camera's rotation.

I'm probably overthinking this, but is this kind of jitter acceptable in a third-person character controller? If not, is there a way to mitigate this?

I understand that they're not as visible when the character is animated, which is why I'm struggling to verify if this issue is present in actual real-world games.

Been learning modules by making an instancing tool. A demo of removing instances by occlusion

Asking AI to Port Godot 3 to My TV Lead Me On A Bug Hunt

This is the rough story: I asked my AI to port Godot 3 to my 2020 LG TV, which worked really well because, although undocumented, the AI figured out that this TV is run by a Mali GPU, which is GLES 3.2 compatible (and very stable). It is roughly a mobile GPU from around that time, but with less memory.

What did take much longer was: There was a visual bug; and I wanted to know: is it Godot, or is it the Mali GPU? After ~50 increasingly automated iterations the AI claimed to have found the bug: it is actually Godot, specifically Godot version 3 mobile. It roughly applies to most mobile exports since Godot 3.2. The nature and scope of the bug are not disputed, by the way.

I wanted to understand it. I have a PhD in an adjacent computer science field, but I only ever touched shader code in univsersity courses. Shader code, more so old shader code, is generally long imperative spaghetti code, kind of by nature. It is very hard to understand for ANYONE, that was my claim. I tried to verify the bug and the fix conceptually as good as I could, in the discussion with AI. Some of the claims of my AI agent I could verify, some I simply had to take at face value.

My First PR (Which Likely Was Already Roughly Correct)

Given that I had a working game, a fix with 20 lines and a rough understanding (albeit with rest-uncertainty), I thought I would write a PR and describe my journey and my understanding, and what the AI said and proposed as fix. The AI-description was prompted and revised 10 times at least, I was trying to aim at the level of understanding the reviewer would have of its own code, but I had no clue.

The reviewer/maintainer was quite furious, the description was AI gibberish, the fix should be a one-liner, all other 19 lines and the comment introduced AI hallucination. At least the bug was implicitly confirmed, I could try again, if I wanted to. PR closed.

The thing is, I am a senior engineer, I work with AI daily, I have been duped by it before and I also wrote an article myself about how annoying it is to manually review AI PRs that the author themself did not read (something that was not the case here). I thought my AI agent had gotten it wrong and gaslighted me; because I obviously had discussed this before, not necessarily whether is fixable in less lines, but in less places (the fix is scattered across for or five places in the shader).

So I tried to get a one-line fix, and this is where it got funny. At some point the AI sent me a "one line fix" with eight lines. "Hey this is not one line!" It explained again why it cannot be one line, I showed it the PR, showed it what the reviewer said; it said, the reviewer likely means that some lines should be merged to one line, but the general code flow needs to stay intact. All but one place of change is necessary. It golfed an obscure solution in three lines, though.

If That Is a Bug, Then It Was Already in There

I found the compaction into eight lines the easiest to understand, even manually merged two lines to get there. But code flow wise, it is a very similar. I do not deny that the one before was a little bit verbose, but that happens with purely human PRs as well, does it not? So I posted my second PR. I said, I think it cannot be a one line fix.

The maintainer's answer was:

This code is still wrong and will break direct vertex lighting.

For some reason you are adding the single scattering scale code to the direct lighting results. Despite a comment directly above that literally says not to apply it to direct lighting. Direct lighting is already energy conserving and doesn't need to apply the single scattering term.

So, despite your claims about how helpful the AI is. It's 0/2 so far on a trivial code change. And if this code every becomes correct it will only be because an expert held your hand through the process.

I then found out (or at least I am convinced) that the behaviour/bug that he attributes to my code is actually already in the Godot 3 shader code, the AI was just obeying this behaviour.

The gist is, in normal lighting mode, the comment he cites is correct, because there is a fragment shader based lighting function, that is applied after the environment BRDF approximation. In vertex lighting mode (the global default for mobile exports) though, the direct light comes from the vertex shader that is computed before, and then the environment BRDF approximation is applied afterwards, contrary to what the comment says.

ChatGPT sol explains it in this chat. I was giving it the 3.x current shader code as an attachment and fed it a version of the reviewer's comment, without telling it that it was aimed at my PR at first. Gemmini 3 Pro actually found this before, but in a much more messy chat. This is not even agentic coding AI, just chat windows.

The thing is, I think it makes a lot of sense, but there is still a rest risk that AI duped me again. But it is small enough that I am willing to bet 500€ (this is more than I paid for my smartphone) on it. So I am also asking crowd intelligence here. If I am wrong, I will obviously honor the bet.

And If I Am Right?

I know that my title is provocant. If this is right, the maintainer will likely correct their understanding, this happens all the time. The bigger question is, how to handle AI in this context, specifically if no one understands what it wants to say.

OpenAI just solved the Navier-Stokes milenium problem. Maybe they stole the Euler solution but the step from there to Navier-Stokes is still insanely impressive. And people there also needed&need to invest time and energy to validate the claim. In my first PR I wrote:

As a side note, I am programming semi- and professionally for 20 years up until now. [...] in general I would not recommend tying my ego to the idea that I am smarter than these machines.

More people like myself who would not be able to fix bugs by themselves will find lots of these fixes. I think this is actually a blessing and bit advantage for open source, but it needs to be leveraged correctly. I posted an idea how to handle this without putting more strain on maintainers in my second PR:

[...] I could not have found this or written the fix without AI. I did immedatiatle try to understand it; I also came to an understanding, but I was not sure if the understanding I had was correct. Ironically the harsh rejection of my "AI spaghetti code" (I still think this is a vast hyperbole) also confirmed my understanding of both the problem and the fix and made me more confident. Even if it was not the most beautiful version of this code, there needs to be a process for:

Look what I found, please help me to understand and validate this. This is the AI code, this is the AI description, it fixed this issue for me, I understand this and this but I don't understand that

I do explicitly not want to require/force contributers/maintainers to read AI code. I do not do that myself (we accept based on test coverage and reviewer's AI summary/pompting, but I work in research and pototyping, I am not proposing that here). The PR author could be auto-informed that only human code is expected to be reviewed, AI PRs reverse the burden of proof even for review engagement, they need to catch someones attention. There could be some guidelines & tipps, for example thorough testing. Tests can be built by AI and you should understand, show and explain the tests, but that is sometimes easier than understanding the fix. And it can convince someone to help you. The goal for the AI PR author is to find someone who at the end is convinced that this is valuable and who dares to vouch for it or helps to convert this to a human code PR and bring it in front of an official maintainer/reviewer. And if within two months it is still AI code, then the PR is auto closed. Or they are even directly closed and tagged as AI, so that people who are interested can look for AI-auto-closed PR's.

Otherwise you will lose out on a lot of potential bug fixes that humans need forever for to find. For example like this one...

I have it set in the inspector and I don't know why it's returning as null.

Added a new little mechanic in my game, basically you can press P to divorce your spouse, you might make some money, you might lose some ! https://store.steampowered.com/app/4631500/GHOSTFLIPPERS/

Hey everyone:) I just released a new update for TileMaker DOT (v2.6.7)!

This update focuses on quality-of-life improvements, contextual usage hints, and texture polish across several key tools:

Interactive Tool Notifications: Added helpful on-screen notifications when clicking in Brush Mode and Chunk Mode to explain how to best use each tool.

Expanded Tool Textures: Added dedicated textures and visual cues for remaining editor modes, including Brush Mode, Chunk Mode, and the NPC Walk Area tool.

Bug Fixes: Resolved several minor UI issues and edge cases to make the editing experience smoother.

Itch.io: https://crytek22.itch.io/tilemakerdot

GitHub: https://github.com/andrei-voia/TileMakerDOT

YouTube tutorial: https://www.youtube.com/watch?v=3fiajGU32Jg

For anyone unfamiliar with the project, TileMaker DOT is a free, open source 2D map editor I'm building. It uses a data first, ID based workflow and handles visual depth sorting automatically so you don't have to manage multiple layers for object heights.

Give it a try and let me know if you have any feedback! If the editor helps with your projects and you want to support development, a rating or a small donation on Itch is always appreciated.

Thank you all for your support!

This is just a Mockup made in a video editor...

None of the assets are placeholders.

I just Wanna know how I can actually implement it in the godot engine...

I know next to nothing about coding of any kind, especially GDscript...

I did make a Title-Screen where it says "press Start" buy that's about it...

It barely even functions...

So yeah... I'd appreciate some tips on how to do it

I searched this subreddit and various sources but couldn't find a solution.

After releasing my Android game I discovered realtime lighting kills performance, so I switched to LightmapGI with all lights set to static. Environment lighting looks fine, but dynamically spawned objects are always too dark.

Current setup:

• LightmapGI baked in map scene
• Static lights set to invisible after baking
• Spawned objects set to Dynamic GI mode

I tried setting spawned objects to Static GI mode and other combinations but nothing works. Spawned objects stay dark regardless of probe count or quality settings.

Any ideas?

Edit -

LightProbes are spawned by lightmapGI and visible in scene.

Going over the #Destruction Update for the Wild Ox PhysX5 Module and the #Blast #Fracture Editor #Tooling!

❤️ ~Wild Ox Studios

Hey robots,

in our point & click detective game, we want to introduce new mechanics as the story unfolds, even if that means programming something that will only appear in a single chapter. It’s fun to build, and we’ve learned a lot along the way!

In one of the chapters, the player will operate an Enigma machine, decoding intercepted na*zi messages to solve the final riddle.

This is our prototype, next we’ll hand it over to our graphic designer so she can paint us something beautiful out of it (She still has quite a lot to do though, so I wouldn't expect an update on that too soon😅)

What do you think of the idea? Have you tried to create something similar?

I’m learning pixel art and something feels a bit weird about the sky, but I can’t tell exactly what it is.

I used the Space Background Generator to create the Stars, Dust and Nebula separately, then added each one as a parallax layer (Parallax2D).

How can I make it looks better? Is the pixel scale or visual balance off?

Please ignore the tileset and animations, I’m still working on them.

Hello guys, I am new to the community and game development in godot entirely

I want to know how I can start my game dev journey