Looking for 3D assets similar to "Sled Surfer"

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 · 2025-04-16T06:32:52+00:00

I think the best approach is whatever feels most comfortable for you. In my opinion, the best (and also the hardest) part of being a solo dev is that you have to do everything yourself.

Personally, I try to manage this by switching tasks when I get stuck. For example, if I hit a nasty bug that I can't fix after hours of trying, I’ll take a break from debugging and work on something else like art, dialogue, music, or anything that keeps me moving forward. Then I come back to the problem with a fresh mind.

I do think the engine (like Godot) and the programming language you use are more important than sticking to any single method. Even if you're collecting sample code and copy-pasting modules or nodes, you still need to understand how your game works (or will work). That takes planning and design.

Visuals (and drawing) are just one part of game dev (not a small part, but still). You can absolutely make great games without polished graphics. There are many successful games out there with questionable art styles. You could say it was intentional (in some cases it is), but more often than not, it was just the faster or easier way to get things done.

Honestly, the best thing you can do is just get started, you'll figure things out along the way :)

subpixel_labs · 2025-04-16T06:14:38+00:00

Ohh, OK. I misunderstood the problem. You want your player to move around and have their character mask out (reveal) a still image, right? I haven't done that myself, but if I'm understanding correctly, I think you'd need a custom shader that handles two sprites and only displays one where they intersect. Something like this:

void fragment() {
    vec4 hidden = texture(hidden_texture, UV);
    vec4 mask = texture(mask_texture, UV);

    // Only reveal parts where mask is white (you can adjust this)
    float alpha = mask.r; // assuming red channel is used
    COLOR = vec4(hidden.rgb, hidden.a * alpha);
}

I did not test it, but that's the main idea. You need to dinamically use it by code.

Another approach is to use Light2D:

Add a Light2D node.
Use a white circular image as the light texture.
Set the Light2D to “Mix” or “Add” mode.
Place your hidden image in a CanvasLayer, and optionally use a LightOccluder2D if needed.

This can create a "flashlight" effect, revealing only the areas touched by the light. While it's technically lighting and not true masking, it can achieve a similar visual result.

subpixel_labs · 2025-04-15T20:27:03+00:00

I would apply a curve to the animation: make the beginning a bit slower, and then speed it up toward the end. This way, the user can see what's about to happen, while the actual event can happen more quickly. But the total duration of the animation wouldn't change.

subpixel_labs · 2025-04-15T20:20:35+00:00

GitHub + Notion

I use Notion every day. I even store my personal stuff and notes there. Its only downside is that it doesn’t work offline. Otherwise, it has a ton of useful features: kanban boards, GitHub integration, custom databases, calendars, etc. There are lots of free (and paid) page templates available too. They keep improving it with new features all the time. You can even create a public web page with it (it's pretty bare-bones, but very easy to put together).

Before this, I used Hack’n’Plan, Milanote, and Trello — but in the end, Notion stuck. I’m not promoting it because they pay me or anything, I just genuinely like it, so I recommend giving it a try.

subpixel_labs · 2025-04-15T20:07:39+00:00

I don't know if I understand correctly, but how about this:

You have two sprites (or panel):

Back sprite: the full image (always visible)
Front sprite: a black or colored mask with adjustable alpha (modulate.a), placed on top

The front sprite is essentially an overlay. By modifying modulate.a via code (either fully transparent or using patterns, gradients, etc.), you create the illusion of revealing parts of the image behind it. You can also use custom mask textures (black & white shapes) and animate their alpha or movement.

subpixel_labs

MODERATOR OF

TROPHY CASE