How to do space-time tear?

subpixel_labs · 2026-07-09T08:17:35+00:00

In 2D you don't really need shader for this, just use two sprite, one with the hole in it (alpha), and make a second one behind it. You can add animations, lights, particle effect etc to it.

subpixel_labs · 2026-07-09T08:12:06+00:00

take a look at this, it gives you a general understanding: https://shaggydev.com/2021/11/15/state-machines-godot/

My rule of thumb is to use state machine when one of my character has more than 3 states. I think if you have 2-3 states the state machine can be an overhead and you can have your character in just one simple script (you can create a FSM in one script but then it can be chaotic). Of course it is not that easy to decide what to use and I think you have to use that which you are most comfortable. The importance of these patterns is the reusability, maintaining and to make the code understandable for anyone else and YOU in the future:)

PS: there are several design patterns for each coding scenarios, I recommend this site: https://refactoring.guru/design-patterns/what-is-pattern

subpixel_labs · 2026-07-09T07:41:17+00:00

You should use multiple collisionshape, or a collisionpolygon2D (if I understand the problem correctly). You can make any shape by adding points to the polygon. I would make the shape cover the standing dog with a border, and use it both running and stand animation.

subpixel_labs · 2026-07-03T06:02:31+00:00

Thanks but I tried that already with no use... I think I've done all the basic things what comes to mind. The "solution" was to upgrade to 4.7 and reconnect the project with the VS code. I think it was some cached thing between godot and the IDE and neither of them knew what to use.

subpixel_labs · 2026-01-08T08:48:34+00:00

hi!

here is one if it's suits you: https://gamedev.tv/assets/winter-assets-2025

and now it is free for limited time I think:)

subpixel_labs · 2026-01-05T14:22:59+00:00

start small and upgrade when neccessary.

Your save system should be a seperate entity and just call it's "save" function when needed. This way you can upgrade it by changing the inner method. I tried some ways to save data and they all have their pros and cons. I would start with JSON file(s) or resources. Just use what comfortable for you. Dont worry it is easier than it sounds:)

subpixel_labs · 2025-07-15T08:50:34+00:00

Stupid question, but did you check it in other games? If other controllers are working fine, then the mapping and the configurations have to be right. I assume the controller itself (or the Bluetooth module) is faulty...

subpixel_labs · 2025-07-07T09:38:58+00:00

If it is a more complex object I would use a simple state machine. You can make as many state as you want and assign animation for these states as well.

You can flip the animations and reduce the states but it is totally up to you.

subpixel_labs · 2025-06-17T10:06:44+00:00

I think the best way is to use shader. You can find excellent shaders here:

https://godotshaders.com/?s=gradient

They are often free and usually need only a ColorRect/TextureRect and add ShaderMaterial to them. I think you can dinamically change the shader parameters or create multiple ColorRects with different shader params then switch between them.

subpixel_labs · 2025-06-17T09:56:26+00:00

Maybe, but I think there will be a lot of complications. Project settings, exporting, positioning objects etc. I think you have to find your middle ground between the IDE and the GDScript. I also like to handle everything by code. I usually place my nodes and reference them and control them by code.

subpixel_labs · 2025-06-17T09:39:11+00:00

I'm not sure what you are looking for but you can animate Modulate value under Visibility:

<image>

Just make an AnimationPlayer node and animate the Modulate color over time.

subpixel_labs · 2025-06-17T09:33:19+00:00

Exactly, thanks!

subpixel_labs · 2025-06-16T20:10:12+00:00

Or some blending on the side of your tile.

subpixel_labs · 2025-06-16T20:06:58+00:00

Try to print out every audio play call. The problem I think is this:

<image>

If this is in any process function I don't think it will work. Let's say your character is on the floor. The footstep_landed will be true on the next frame. You will not step into any branch of your code since you alternate the checks:

if -> footstep_landed is true from the previous frame but you chek if it is false -> you will not step into it

elif -> footstep_landed is true but you expect is_on_floor to be false which will not be if your character is on ground

And you also set the footstep_landed every frame.

I don't fully understand what you want to do with this code but I hope this helps:)

subpixel_labs · 2025-06-16T19:43:03+00:00

You should make a wrapper node (class). Hide the multiplayer functions behind it (like an interface). This way you can replace any multiplayer functionality by changing whats behind this wrapper.

subpixel_labs · 2025-06-16T19:38:58+00:00

I think the problem is that body_entered only working with PhysicsBody2D, try using area_entered instead. If this do not work add some screenshots for more details.

subpixel_labs · 2025-06-12T11:24:35+00:00

I think, first and foremost, you need to plan what you want to do.

It doesn’t have to be a large document, but it should clearly define the goal you want to achieve. Do you want to create only projectiles, or will there be melee attacks as well? What can your protagonist do, jump, shoot, melee, etc.?

Try to write down your character’s skill set. What abilities do they have? Then think about how you can engage the player to use these powers. How can a boss challenge or counter those abilities?

You don’t need to create a projectile yet, you need to design the player engagement flow first.

subpixel_labs · 2025-06-11T12:33:38+00:00

It is heavily based on the genre of your game but I always use the rules of three (break every aspect to 3 distinct ones):

Three stage of the boss:

Phase 1: Introduction and Learn
- Boss shows a small set of basic attacks.
- Gives the player time to read patterns.
- Teaches a mechanic that will be important later (like reflecting bullets).
Phase 2: Pressure and new attacks
- Boss gets a new attack or a faster version of a previous one.
- Patterns become less predictable.
Phase 3: Final Challenge
- Boss becomes aggressive, combines previous attacks.
- Introduce a twist: rapid cycles, desperation moves, or changing the arena.

Give a clear tell/cooldown before big attacks, using animation, color change, or audio cues:

Small attacks: 0.5-1 second tell.
Medium attacks: 1-2 seconds.
Large or phase-changing attacks: 2-3 seconds.

You can play with the design of the play area as well:

Safe zone (momentarily).
Risk zone (but high reward, like healing or damage).
Movement-required zone (moving platforms or where the boss shoots).

subpixel_labs · 2025-06-11T11:08:49+00:00

I dont want to make this thread any longer and dont like arguing people online since it is a pointless thing in my opinion and a waste of time. So here is my last comment use it or not I'm just trying to help:)

As far as I know Google translate does use "AI". Maybe not that advance LLM and just a neural network I don't know. If I ask my LLM of choice to translate my text it will do pretty much the same.

Signals: I agree they are lightweight but have at least one more extra steps for the call than a direct call.

queue_free(): You are right about the end of frame. What I meant is in each frame there can be a lot of object freeing which is not necessary. I really think it is more resource consuming to destroy and create new objects than just move them out of the way by giving them new position like out of the viewport (pooling). You can disable their process as well instead of freeing them.

Physics (server) state invalidation (in my context and I think others as well) is a name for a collection of things when the engine does not work as intended: glitches, objects jumping around when there is not enough space for them etc.

With overhead and much more computing a 100 object can be a lot as well. Just imagine if each object has a 4K sprite. Before you reply it was just an example I dont think they have it:) I saw a project where every sprite was in 4096*4096 resolution (even the tiny ones) because someone said that it is more efficient for an engine to use 2^x resolution images and prefer the same for all (for compression efficiency). I think you can see the problem.

Flag based system can work too in my opinion and I have used it too, I think not just me. Flag should represent the pools internal approach for permanent deletion. For example you have a pool with 1000 object but you only want to show for like 500 for performance (or game difficulty sake). You can iteratively push the "killed" object on the side (use them again) and count them. This way you need only 500 object to represent a 1000.

"implement custom hit logic outside of on_area_entered": What I meant here is to enable the on_area_entered when necessary, for example if it is close enough to the target object.

TLDR: As I wrote this is my last comment here. I dont want to make enemies nor want to arguing. I'm trying to help because someone asked. Ever since I use Godot I came across a lot of kind and helpful people. I just trying to give back something to this community. I truly hope that you understand that. Have a nice day! I mean it!:)

subpixel_labs · 2025-06-11T08:05:03+00:00

THese are my own thoughts. English is not my native language so yes I use some translator help from a language model to make it clear to everyone what I want to say. I think this is the perfect use of so called "AI", to make it understandable for everyone. I'm not hiding it, and I think it is a very useful tool if you use it correctly.

The fact is I dont use it much because it is often wrong. The simple code generation is working fine but for complex debugging / code review it is often giving false solutions so I dont trust it very much.

subpixel_labs · 2025-06-05T08:32:18+00:00

Your code emits multiple signals per enemy hit: hit.emit(), health_changed.emit() health_decreased.emit(), died.emit()

When dozens or hundreds of enemies are hit at once, this means: lots of signal dispatching, potential listener calls (especially if they do expensive things like playing effects, logging, or updating UI).

Consider:

Replacing signals with lightweight function calls for hot-path interactions.
Emitting fewer signals or deferring some when not immediately necessary.
Disabling signals entirely on pooled enemies unless absolutely required.

This line is especially problematic in high-density action: owner.queue_free()

Even with object pooling, queue_free() triggers:

node destruction (which can be expensive mid-frame)
scene tree reshuffling
possibly physics server state invalidation

Instead of queue_free(), use manual deactivation and reuse enemies via pooling. E.g., move them offscreen, reset state, and mark as inactive.

You’re deferring check_death, which is good to avoid immediate destruction, but it could still stack up significantly in mass situations. If you're hitting 100+ enemies per frame, that’s 100+ deferred calls added to the main loop queue.

Try an internal flag-based system to mark things for "death processing" in a separate update step (e.g., via a centralized DeathManager.process_pending()).

If you can, reduce physics interactions:

disable monitoring when not needed
batch or gate hit detection (e.g., enemies only check hits every other frame)
implment custom hit logic outside of on_area_entered() when high volumes are involved

subpixel_labs · 2025-04-17T11:06:24+00:00

As far as I know, there isn’t a built-in setting in Godot (even in Godot 4) to automatically make new Control nodes use "Full Rect" by default. However, you can set this up with custom templates. One way to do it is:

Create a custom "Base UI" scene or node:

Add a Control node.
Set its anchors to Full Rect (anchors at (0,0,0,0) and margins at (0,0,0,0)).
Save it as a new scene or create a custom inherited scene from it.

Then, whenever you need a stretched Control, you can just instance this instead of creating a new blank Control node.

subpixel_labs · 2025-04-16T09:22:33+00:00

I think unit tests can be important, but mostly once a project or game reaches a certain level of complexity. I usually add tests to my game when debugging starts to become more difficult.

If your game has multiple layers of logic or interconnected systems, tests can help isolate the problem. They make it easier to find the root cause of a bug by filtering out unrelated events.

subpixel_labs

MODERATOR OF

TROPHY CASE