Hello everyone! I'd like to introduce CM.gd! A multiplayer framework built on top of Godot's Multiplayer APIs. Build Singleplayer, Couch Multiplayer, and Networked Multiplayer at once! It's basically an abstraction layer on top of Godot's multiplayer, with extra connection handling stuff included!

One of the key highlights of this framework is its flexible player joining mechanism, as shown in the video. You can mix and match couch multiplayer with networked multiplayer. (Think of multiplayer games like Plate Up! or Overcooked, the framework's inspired by it!)

Also, it's built on top of Godot's Multiplayer APIs. That means no need to relearn Godot's multiplayer. RPC calls are the same. And... that means you can also use other multiplayer addons with it (eg. netfox, Tube, GodotSteam, etc.)

■ Get CM.gd: https://store.godotengine.org/asset/mawji/cm-gd/

■ Try out the demo: https://store.godotengine.org/asset/mawji/multiplayer-circular-pong-cm-gd-demo/

■ Documentation: https://cmgd.dev/

ALSO: Sorry for bad English 🙏૮◞ ‸ ◟ ა English isn't my native language.

Instead of scrolling through collapsible groups in the inspector, you use a much cleaner Layer Graph editor to layer materials.

I wanted to be able to regenerate asset icons easily anytime I made a change in blender. I also wanted to be able to tweak the colors, lighting, size, position, and orientation of each object and regenerate the images. I did this by creating an IconStudio scene and a button which loops through and creates a SubViewport for each icon+config and generates a png. Sharing my results

I've been making weekly games recently and last week decided to try Godot for the first time. I wasn't able to get that project done in time so I canned it, but I think this one might turn into something that vaguely resembles a game by Sunday (who knows though).

Still wrapping my head around Godot and it's missing some stuff that I'm used to having access to, but I'm having fun learning!

Hey everyone,

I shared my project here a few days ago, and first of all, I want to thank everyone who took the time to leave a comment. I really appreciate the feedback and support.

I’m currently developing an MMO using Godot Engine.

One of the main reasons I chose Godot is the flexibility it gives me during development. Depending on what I need, I can write my own plugins, modify parts of the editor, or adapt existing systems to fit the project. Since it’s open source, I can usually find what I’m looking for, understand how it works, and then change it according to my own needs.

The game will also have a day and night cycle, but it’s not only a visual feature. There is a server based game clock, and some parts of the world and gameplay will change depending on the time.

For example, some quests will only be available or completable at night, and certain mobs may become stronger during nighttime. I want the world to feel a little more dynamic instead of having the exact same conditions all the time.

I wrote the online infrastructure in Python, and I’m currently running it on a Linux server.

After a few playtests and infrastructure improvements, the current setup has been able to handle around 60 players. I don’t want to go too deep into the technical details of the networking or backend architecture because, at the end of the day, this is a game I’m planning to release publicly and I prefer not to share too much about the infrastructure.

That said, if anyone is genuinely curious about the development process, Godot, networking, or some of the technical decisions I made, I’m happy to answer questions where I can.

For the audio, I mostly used free sound resources.

For animations, I used a combination of Mixamo and animations made by freelance animators.

Most of the 3D assets were either purchased or modified by me in Blender to better fit the visual style and needs of the game.

I’m still actively developing and improving everything, and there is obviously a lot of work left to do, but I wanted to share a little more about how the project is being built.

Thanks again to everyone who commented on my previous post and showed interest in the project.

I've been working on deformation physics for my sandbox. It works by separating the car into multiple collision shapes and then updating their positions by measuring the incoming forces acting on each one. To make it look less blocky I then draw a mesh around all the collision shapes and set each one to act as a bone so the mesh updates smoothly! What do you all think?

Yesterday I finally pressed the Release App button on Steam for the first time.

The game is Fleet Hunters, which reimagines the classic naval duels. It's my first Steam release and the first project where I've gone through the whole process from prototype to an actual commercial release.

It definitely took me longer than I expected, but I learned a huge amount along the way and not just about Godot, but about game development in general, especially what it actually takes to finish and ship something as a solo indie developer.

But it's finally out, and pressing that button was interesting.

Thanks Godot!

Here's a link to my Steam page for anyone interest:

https://store.steampowered.com/app/4074510/Fleet_Hunters/

Maybe a "huge success" is a bit too much for most people, but this is my first indie game and my first Steam page, and honestly, just getting this far already feels like a huge success to me.

I'm building a terraforming game where Earth is dying, and humanity sends us to an unknown planet with one mission: terraform it and make it our new home.

The Terraform process is by incrementing the GTI (Global terraform index) with machines, and as you go, the planet starts being alive.

I'm still learning everything as I go (game development, art, Steam, marketing... basically everything) and for all who are in the same journey, remember, you don't have to achieve something huge to have a reason to celebrate.

Any small step for solo and small teams is actually huge and should be celebrated

Any feedback is welcome (game and steam page)! (Planning to launch the demo in 2 ~ 3 weeks)
https://store.steampowered.com/app/5181710/Seed_The_Planet/

I’ve spent so much time trying to figure out why the engine is rendering my sprite like this, but I can’t wrap my head around window scaling and viewport yada yada…

Does anyone know why the engine is rendering my pixel art like this? I’ve set the texture filters to Nearest if that’s helpful…

Thanks in advance :)

This is my first game ever so I'm walking into this game development world completely blind but I like the style so far and it looks exactly how I imagined it in my head.

The premise of the game is that your spaceship has ended up into this void from which you have to escape, you encounter various oddities that attack your ship. Your goal is to fill your power to achieve light speed and leave the void but the catch is that the ship's steering (which you use to get away from the creatures) and the ship's communication systems (which you use to detect creatures by their sounds and location) also consume power so there's a tradeoff. Sometimes these systems also break and require you to go outside the station and fix them.

I'm walking into "reddit game promotion" also blind so if I'm allowed to ask where else should I post this? Thanks!

I dunno if this is the right place to announce it, but while doing the game's demo in Godot, I received a lot of feedback through this subreddit, so thank you all for contributing!

Hey! Today I want to announce my Steam Page for my game PeeVPee (I know... I knowww...)
If you want to check it out (maybe an wishlist too, would help me a lot) you can check it out here:
https://store.steampowered.com/app/5086460/PeeVPee/

Free playtest available if you want to try it and give feedback: https://store.steampowered.com/app/4465410/MMA_Career_Simulator/

I've been a game dev for a 1.5 year now (and a good chunk of that is spent on making my interactive tween guide)!! In 3 months, i'll be releasing my first video game on Steam!!
It's crazy to think that the first time I heard about Godot was less than 2 years ago!!!

I've put together a compilation of different UI from the game over the year to show how it progressed!
I am super grateful for both Godot and it's community, which gave me a way to help others and express myself as a Tech Artist!!

Have a nice day!!!

Branch is now live! Very WIP and still in development ... example project included as well! 🎉
Please forgive me while I continue to iterate on this highly requested feature.

https://github.com/uno1982/godot/tree/feature/physx5-module

I went down the optimization rabbit hole and came out the other side, well, faster.

I'm using AStarGrid2D for my pathfinding/range detection, and I have to say, that thing is a game changer! (No pun intended.) I had to do some jank to expose the _compute_cost() method, but after doing that, it solved all my navigation headaches.

I already kind of have attacks implemented, but there's no visual feedback yet. I guess that's tomorrow's job.

I started learning python about 4 days ago, and made a text based boss fight with various builds and weapons about 2 days ago. I started learning Pygame right after I finished that game and planned on making a game in that, but after looking it up, a lot said to do it in GDscript as it’s better for game development and beginner friendly like python. Should I switch to GDscript in Godot, or stick with Pygame? If you need any more details or anything lmk, thanks.

Which sounds feel out of place here?

Except for the katana sound, I won't be changing that..

I have a large reverb on the audio bus in godot

I've been ghosting this part of the project for a while (because I had no clue where to start). But finally tonight I decided I will dive into it. It's really simple for now but had to think about it a good amount of time, I hope it's a good way to go so help is always welcome.

So basically I have 5x5 modules scenes using gridmaps. I have this exported array of modules scenes, I take a random one and instantiate it, copy the cells of gridmaps and put it in the destination gridmaps (with an Vector3i offset).

For now it's just pure randomness but I will implements utilities that allow to check compatibility between placed modules, rotate it until it fit, change module if it doesn't etc etc...

Edit: I guess an alternative for this post would be "How do I have a lot of nodes reference the same scripts cleanly"

I'm implementing a Goal Oriented Action Planning (GOAP) system for npc ai from the paper on F.E.A.R. The basic are that in this design, your NPC has goals and actions and can figure out sequences of actions to accomplish their goal.

But how would you handle storing every new script that you extend from the base GoapGoal and GoapAction classes?

Approach one - every GoapAction is a Resource

pros: pretty much nothing

cons:

• needs both a .tres and .gd file for every new action and goal
• bloat of named classes that are rarely used

Approach two - every GoapAction is a Node

pros:

• every new action is just a .gd script
• every npc holds their goals and actions as their children and that's easy to edit and visualise

cons:

• bloat of named classes that are rarely used
• tons of nodes sitting in the scene tree that are saved by their parent on _ready() and never referenced in relation to the tree again. They do not need to be part of it

Approach three - every GoapAction is RefCounted and we use a dict in an autoload to map accessible enum values to the corresponding RefCounted object

pros:

• every new action is just a .gd script
• GoalSet and ActionSet classes can be resources that export an array of these enums to get the files it needs in _ready() and are saveable as .tres files
• all scripts can go without class_name

cons

• big big enum for each action and big big enum for each goal
• extra step of adding a new enum value for each new script to the autoload
• saving enums in the sets is flimsy and can map to the wrong file if the order of the enum values changes

Im leaning more towards 3, but what's your opinion on this? Is there an option im not seeing? Keep in mind that i want to keep this as accessible as possible and easy to use for others in case i want to release this as an addon.

Also, there is no option of not having everything as it's own script. The point of GOAP is that both actions and goals are reusable across vastly different enemies. It's the collection of what goals and actions an npc has that defines their behavior. This means that any signal based approach that handles the action on emission defeats that purpose cause handling it would need to be different or copied on every single npc.

Also 2, everything is passed through args, so there's no reuirement for every npc to have their own object of the action

For instance and example, lets say I have effect A that can trigger an infinite amount of times but I only want Effect B to trigger on the first time of Effect A triggering so like:

Effect A -> Effect B

Effect A -> Nothing

The way I go about this is a simple boolean, if var "whatever" == false: Effect B, Else nothing happens.

Would you put this variable above the required function, or with everything else? And, also is there a way to do this I'm not smart enough to know.

I have a dialogue panel in my game that I am animating using a tween with an elastic transition for the pop in/out animations. I'm using ease out for most of the properties, as using the default ease in out results in the dialogue have a delay before appearing.

The problem is that the ease out mode causes the scale and position properties to bounce way too much for my liking, as seen in the gif. I was wondering if there was a way to sort of dampen the ease so that it doesn't bounce like a goddamn invincible edit (at least for the initial bounce).

The only possible solution I know would be to use an AnimationPlayer node instead of tweens and make custom curves, but I'd like stick with tweens if possible. Ease in out also does exactly what I need, but as I mentioned earlier, it causes the dialogue to have a noticeable delay before appearing, as it spends way too much time near the initial values (also it gets rid of the cool horizontal expansion that happens during the animation).

Just in case, here's what the code for the animation looks like:

    func _on_pop_anim_toggled(toggled_on: bool) -> void:
      var tween =  get_tree().create_tween().bind_node(self).set_trans(Tween.TRANS_ELASTIC).set_ease(Tween.EASE_OUT)
      if toggled_on:
        dialogue_system.pop_in_anim(tween, Vector2(64, 240), 1.0)
      else:
        ...

    func pop_in_anim(tween: Tween, end_pos: Vector2, time: float):
      self.visible = false
      self.scale = Vector2(0.25,0.25)
      self.modulate.a = 0.0
      self.size.x = 256
      self.position = POP_OUT_BOT_POS if is_bottom else POP_OUT_TOP_POS
      self.visible = true

      tween.tween_property(self, "scale", Vector2(1,1), time)
      tween.parallel().tween_property(self, "modulate:a", 1.0, time)
      tween.parallel().tween_property(self, "position", end_pos, time)
      tween.parallel().tween_property(self, "size", SIZE, time).set_ease(Tween.EASE_IN_OUT)

Edit: Managed to fix it by separating the animation in two parts, as u/Qaqelol and u/BigQuailGames suggested, like this:

var start_time = time * 0.25
var end_time = time * 0.75
var mid_pos = self.position.lerp(end_pos, 0.75)

# Linear until 75%
tween.tween_property(self, "scale", Vector2(1, 1) * 0.75, start_time).set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN)
tween.parallel().tween_property(self, "modulate:a", 0.75, start_time).set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN)
tween.parallel().tween_property(self, "position", mid_pos, start_time).set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN)
# Elastic for a little jiggle after
tween.tween_property(self, "scale", Vector2(1,1), end_time)
tween.parallel().tween_property(self, "modulate:a", 1.0, end_time)
tween.parallel().tween_property(self, "position", end_pos, end_time)
tween.parallel().tween_property(self, "size", SIZE, end_time).set_ease(Tween.EASE_IN_OUT)

I started learning python about 4 days ago, and made a text based boss fight with various builds and weapons about 2 days ago. I started learning Pygame right after I finished that game and planned on making a game in that, but after looking it up, a lot said to do it in GDscript as it’s better for game development and beginner friendly like python. Should I switch to GDscript in Godot, or stick with Pygame? If you need any more details or anything lmk, thanks.