Godot

Hello everybody! In this video, I would like to create an effect that transforms a scene into its pixelated version. We've seen that before, right? But this time, we won't settle for ordinary square objects—we'll tilt them a bit to create a diagonal grid with an adjustable size. Let's take a look at how such an algorithm works.

Still working away on Gopilot, my half-finished LLM-powered AI thingy for Godot.

In the example video you can see an LLM agent creating some nodes and a script to make a login screen.

This is a cherry-picked example, but I am working on improving this.

The @action command is required for it to interact with your nodes and project files and such.

The model used for this is Mistrals codestral model which has a free API. It's presumably a rather small model, coming from Mistral.

If you have any questions, ask right away

Hello, 🙂

I created a new language called FuncSug. Its purpose is to make GUI programming in the browser easier and so game programming. The facility consists on eliminating asynchronism: In FuncSug, the code is no longer managed by an implicit/explicit global loop (I don't speak about implementation).

I intend, if I have time, to implement it for Godot as well. In FuncSug, the first tutorial of Godot would be roughly coded as this:

func showMessage(p_message):
	parallel exitWith branch 2 ||
		showIn(p_message, $MessageLabel)
	||
		waitSeconds(2)

parallel ||
	while true:
		# Start of game
		parallel exitWith branch 2 ||
			showMessage('Dodge the\nCreeps')
		||
			waitSeconds(1)
			awaitPressed($StartButton)
		get_tree().call_group(&"mobs", &"queue_free")
		score := 0
		$Player.start($StartPosition.position)
		
		# Middle of game
		parallel exitWith branch 1 ||
			awaitSignal('hit')
		||
			while true:
				playSoundFile('House In a Forest Loop.ogg')
		||
			showMessage('Get Ready')
			parallel ||
				while true:
					waitSeconds(1)
					score += 1
			||
				while true:
					waitSeconds(0.5)
					callgd spawnMob()
		
		# End of game
		parallel ||
			showMessage('Game Over')
		||
			playSoundFile('gameover.wav')
||
	while true:
		await score
		$ScoreLabel.text := score

The 'player.gd' and 'mob.gd' files would be keeped as they are. The "_on_MobTimer_timeout" function would be renamed as "spawnMob" and moved to 'mob.gd'. The timers wouldn't be needed any more.

Can you tell me what you think about it?

cross-posted from: https://programming.dev/post/26509534

So I know the Godot Asset Library links back to some other source like GitHub for the actual files. It also appears that it uses the "git archive" to create the zip file, because you can update .gitattributes to ignore everything but what is in the addons directory which is handy for a plugin.

But does it have any other metrics, like number of times an Asset is downloaded or used? I'm not sure that you can tell from the GitHub analytics if it is pulling it since that table seems to show "clones" and not "archive"s? Also it probably wouldn't look like a new user.

Anyway I was just curious enough to shoot out this question into the ether.

Hi everyone! Let's create a simple algorithm that allows us to remap the colors of our scene to a predefined palette. This effect can be useful if, for example, we want to simulate the screen of an older device that only supported, say, 256 colors, and similar scenarios.

Added the swords to have something else for a change than boxes in all ratios. And, well, every Bulletheaven game needs something to collect, right?

A few seconds longer and it would take off like a choppa

Wanted to have them orbiting while maintaining center alignment, didn't fully work out ¯_(ツ)_/¯ But I do kinda like it

Hi everybody. This is the second part of the tutorial, which explains the basics of a technology called ray marching for rendering a 3D scene using a shader. In the first part, we modeled a simple scene with a sphere, a cylinder, and a cube, and this time we will demonstrate how to properly light such a scene and calculate shadows.

Plug and play hands for FPS with animated weapons.
Feel free to contribute.

Godot Asset Library
Source code

Was really excited to see this and was surprised to find it hadn't already been posted so I figured I'd share ☺️

Hi! The game is ~~nearly~~ complete, I'm looking for feedback before releasing it!

You can check the ~~beta version~~ it here:

https://eibriel.itch.io/robot-anomaly

Feedback is more than welcomed! Thanks!

( The game is open source, you can check the code here: https://github.com/Eibriel/RobotAnomaly )

Hey folks!

In my free time I'm building this simple web-based tilemap editor called Sprite Fusion.

It's written in TS and Rust to export native Godot maps files straight from the browser (and also natively as I have a desktop version of it). For a long time, only Godot 3.5 maps exports were supported, but now it also supports Godot 4.3 exports!

Let me know your thoughts :)

Cheers!

I'm really excited about this.

From the description: "After years spent in Unity I have finally made the decision to move to Godot starting next year."

Context: The default 3D physics engine of Godot is really bad, so one of (if not the) most popular extensions for Godot was Jolt Physics, replacing the old physics engine with Jolt (which is what Horizon Forbidden West uses).

Jolt not only has way better accuracy and less bugs, it also performs better. There is no reason to use the official one compared to this.

What this means:

• Jolt is coming to Godot 4.4, it's currently not a default since it's experimental (you can switch it on in the project settings), but once it becomes stable it will be the default physics engine.

• The Godot Jolt extension will be in maintenance mode since it's now built into the engine itself.

• The old physics engine will still exist for now (probably for backwards compatibility's sake).

The wait for 4.4 continues.

Before the game had an abstract "grab" mechanic. But having a physical tool seems more immersive (Skeuomorphic Design).

Coding that is shocking simple: Trace a ray to the object to grab, get the position, and apply a force on that object from that position towards the player.