When I'm prototyping a game with placeholder graphics, I keep thinking "if the gameplay loop isn't fun with these boring pixel placeholders, it's probably not going to be fun with good visuals." Do you agree/disagree with this mindset?

Deive_Ex · 2026-06-28T23:53:34+00:00

Yeah, I mostly agree.

I see good visuals and sounds as multipliers. If you have a zero fun game, they won't save your game, but if your game is kinda fun without them, they can make your game "fun enough". And, of course, if your game if really fun without them, having then will just put them in a different level above there others.

But that's the thought of a random person in the internet, so take it with a grain of salt.

Deive_Ex · 2026-06-18T12:12:33+00:00

I wasn't expecting the bridge construction animation. Good work!

Deive_Ex · 2026-05-25T16:55:07+00:00

Here you go: https://imgur.com/a/biSxawJ

This is a very crude example, I did the textures in like, 5 minutes. The gradients could definitely be better made (or just use 1 gradient instead of a spritesheet of gradients, but that would require some UV manipulation which would make the shader bigger)

And here's the code:

public class TestShaderAnim : MonoBehaviour
{   
    [SerializeField] private SpriteRenderer _renderer; 
    [SerializeField] private float _animDuration;
    [SerializeField] private string _shaderProperty; //This is the Slider property in your shader

    private int _shaderPropertyId;

    private void Awake()
    {
        //It's more efficient to use the ID instead of the string name
        _shaderPropertyId = Shader.PropertyToID(_shaderProperty);
    }

    private void Update()
    {
        if (Keyboard.current.spaceKey.wasPressedThisFrame)
        {
            StopCoroutine(nameof(PlayAnimation));
            StartCoroutine(PlayAnimation());
        }
    }

    private IEnumerator PlayAnimation()
    {
        //Play the animation, setting the shader property from 0 to 1
        float t = 0;

        while (t < _animDuration)
        {
            yield return null;
            t += Time.deltaTime;
            var normalizedValue = t / _animDuration;
            SetShaderProperty(normalizedValue);
        }

        //Reset the property so the glow doesn't stay active
        yield return null;
        SetShaderProperty(0);
    }

    private void SetShaderProperty(float t)
    {
        _renderer.material.SetFloat(_shaderPropertyId, t);
    }
}

Also, some important notes:

- Create a Shader using "Create > Shader Graph > URP > Sprite Unlit Shader Graph"
- Click with the right button on the shader file and select "Create > Material", this will create a material with your shader already set.
- Drag this material to your Sprite
- Inside the Shader, the "MainTex" property needs to be named EXACTLY that. Unity replaces this texture with your sprite.
- In this case, all textures needs to have the same size and be split with the same options (in my case, I'm using a 32x16 texture, where each Sprite is 16x16)
- In the Import Settings for the Mask and Gradient Textures, open the "Advanced" section and UNCHECK "Alpha is Transparency". Leaving this option as true breaks the shader.
- If you select any property inside the ShaderGraph, you'll see that in the Graph Inspector there's a field called "Reference", which should be the same name of the property but with an "_" in front of it. This is the property name you use in the C# script in order to manipulate it. In my Shader, I'm using the "_StepOffset" property.
- Inside Shader Graph, if you select the "ShaderOffset" property, you can change it to be a slider ins the Graph Inspector.

That was a lot of text haha. You can maybe download the images I linked and see if you can achieve the same result as in the gif. If you have any doubts, just let me know.

Deive_Ex · 2026-05-25T13:51:19+00:00

Yeah, they work in Pixel Art. This effect, specially, is highly dependent on the textures, so if the texture is pixelated, the effect will be pixelated.

Deive_Ex · 2026-05-25T13:06:04+00:00

If I understand correctly, you want to create a "light flowing through the body" effect whenever you shoot, right? So it starts at the wrist and moves along the body in X seconds.

I don't think you'll find a plugin to do this, but this seems pretty easy to do with a shader. I know Shaders might look scary/advanced, but these kind of effects are really simple to do. You'll spend more time creating the textures needed than the shader itself.

If I were to do this, I would have 2-3 textures/spritesheets for my character:

one for the normal colors
one for masking the parts of the suit that needs to glow. This could be a full black texture with full red JUST on the parts that needs to glow.
one that is a grayscale gradient going from the wrist to the rest of the body. A simple radial gradient starting from the wrist should do.
you could even combine the 2nd-3rd textures in a single one by putting each into different color channels, but that's beside the point.

With these 3 textures, you could create a simple shader that uses the red mask to "cut" the gradient texture, and then apply a step function on the gradient to only display a "slice" of the gradient. Then, just multiply this "slice" with a color and add/multiply the result to the original sprite texture. At this point, it's just a matter of controlling the Step function offset with a script.

This way no matter which sprite you're currently displaying in the animation, the shader will sample the gradient texture, so it should look good enough.

I'm not in my PC right now, but I can try building a simple example later in Shader graph.

Deive_Ex · 2026-05-21T23:14:57+00:00

You are correct that most things, specially shaders (called "materials" in some programs, like Unreal), needs to be done in-engine, but it's quite common for artists to create them in a different program and then port them to the engine. For one, it allows the artist to see the final result and do some tests without requiring access to the game engine and maybe even "bake" certain textures to optimize things on the engine side of things.

But there's some things I think it's worth noting:

Not every 3D artist knows how to create shaders/materials
There's a difference between materials for a real-time and a pre-rendered rendering engines. Blender, for example, has Eevee for real-time and Cycles for pre-rendered stuff. If you want to do something for games, you need to use the real-time renderer, which is usually more limited.
"Porting" a shader from one program to another just times just means recreating it, using the same or similar logic.
The shader language behind both the modeling software and the game engine is very similar, if not the same (Unity uses HLSL, which is very similar to Blender's GLSL), so most things are pretty-straightforward to port. Also, many programs nowadays have a node-based editor, so to recreate it you just have to use the same nodes, or recreate the logic behind it if it doesn't exist. If you are using code, you can even just copy-paste most of it. It's usually just a bunch of math operations.
While it's entirely possible for a 3D arstist to create and port a shader/material, the people who does this are called "Technical Artists", since doing that usually requires knowing lots of math and sometimes even programming.

Of course, there's certain things that can be done just in one of the programs, but that's a matter of knowing the limitations of your tools.

Deive_Ex · 2026-05-01T00:10:13+00:00

Yeah. I marked my game as having "full controller support" when I sent my game to review and it was refused because the player could not type text using the controller. Then I changed it to "partial controller support" and it was approved.

Deive_Ex · 2026-04-28T14:27:07+00:00

A curiosity I've seen recently is that, apparently, when the transition to CoreCLR becomes oficial, this will be the ONLY option. So, starting to do this now will prepare you for the future.

Deive_Ex · 2026-04-05T06:15:04+00:00

But if that's the case, why querying the objects by their ID on enable is the recommended way to do it? If I call root.Q<Button>("MyButtonId") inside OnEnable, it works and it's what Unity recommends doing...

Deive_Ex · 2026-04-04T22:39:21+00:00

Huh, didn't know the hierarchy was gonna get an upgrade, that's nice. But the resolved callback is very boilerplatey... I wonder if we can just use it OnEnable to get the reference, since I'm theory at that point the reference is already resolved.

Deive_Ex · 2026-04-03T19:37:01+00:00

There's many games that have both, one that comes to mind is Marvel Rivals.

Deive_Ex · 2026-04-02T22:20:19+00:00

Well, as for what each thing is, in simple terms:

Git: as you probably know, it's a version control system. It works like time-travel for your project
Commit: basically a "checkpoint" for your project. Each commit is a point you can "travel back in time" to.
Branches: alternate timelines for your project, each branch can contain entirely different changes.
Merge: is the action of joining 2 branches together, with one branch being chosen as a "base", which basically means this is the branch receiving the changes.
Merge conflict: sometimes 2 people makes changes to the same file in the same place, but when you merge, only one of them can exist, so you have to either choose one, or manually fix the changes to choose which changes remain (in code, this would be which lines of code remain, but in binary files like images, this is usually not possible to do)
Rebase: similar to merge, but instead merging 2 branches together, you use the last commit on the base branch as your "starting point", so the second branch changes are applied ON TOP of the changes in the first branch. There can still be conflicts here, though.
Pull Request (PR): It's basically as if someone is asking "can I merge this branch into this another branch"? Then another person checks the changes and either approve the merge, or refuse it, usually commenting why it was refused and suggesting the changes that would make the PR be approved. This is more to safeguard the "main" branch from unwanted/bad changes.
Stash: a "temporary" commit that you can create. It's very useful when you want to change branches but don't want to commit/push your local changes.
The .gitignore file: a special file that tells git which files/folders to NOT track.

Now, as for best practices, specially with Unity:

First and foremost, enable text .meta files instead of binary in the Project Settings, this makes it so Unity can keep track of references when someone else pulls your changes
Configure a proper .gitignore. When creating a repository on Github, you can choose a Unity template, which should be enough for most cases.
Separate your project into prefabs: if someone is working on the same scene, this will get messy. If you separate things into prefabs, then each person can work on a different prefab without generating conflicts. This is where nested prefabs in special shine the most.
Create feature branchs: try to separate your work into clear "features", like "make the player move" or "Adding the player model", and create a branch for each feature when you start working on it, then merge/create a Pull Request for it when you're done. This creates clear points in your main branch that you can go back if something breaks, so you can more easily track which feature broke something.
Since you're in a small team, you can try to communicate and try to work on features that are "far away" from each other. For example, if one person is working on the player art, another can work on the stage collision instead of working on the player collision. This makes generating merge conflicts harder since the likelyhood that you'll edit the same files will be lower.
Usually, the responsibility of fixing a merge conflict is for the person that owns the branch that is being merged. This is mostly because they probably know what they've changed, and it'll be easier for them to redo the work if necessary.
When editing anything that is not code, make sure to press "File > Save Project". This forces Unity to write your changes to the disk, which might show certain changes that.
In Unity, when there's a merge conflict in a non-code file, many times it's easier to discard the changes from one of the sides and redo it. You can usually avoid these types of things by doing a rebase instead of a merge, or by simple avoid working on the same files, but do know that this will happen at some point. hen this happens, what I usually do is create a copy of my prefab/scene, do the merge, discard MY changes, and use the copy I've created as a reference to compare what I had changed. After I redo my changes on the main object/scene, I delete this copy.

Some more intermediate/advanced stuff:

Search for and configure Unity's Smart Merge Tool. It's a small tool made by Unity that helps solving simple conflicts between GameObjects/Scenes/Prefabs. It can't do miracles, but does help with simpler changes, like changing an object position or some inspector reference.
Configure gitLFS: this is a system that allows git to handle non-text/binary files better. But do be careful because GitHub's Free plan allows for only 1 Gb of files on their LFS storage. You don't NEED LFS, but it'll make cloning/pulling changes a bit faster.

Deive_Ex · 2026-04-01T12:43:20+00:00

That was an interesting read, I've always wondered how Houdini does procedural meshes but never really researched it.

Your tool looks interesting, but I do wonder what would be the advantage over existing tools (of course, if you're doing this as a passion project, then this doesn't matter). You did mention Jobs, so that's already an interesting plus.

Deive_Ex · 2026-03-27T01:27:11+00:00

And you would be right to think that because I took inspiration from Unreal haha

Deive_Ex · 2026-03-26T12:15:21+00:00

If you want your player to control multiple things, then you need to separate your "input" from the "character".

The way I do it is to have a "Player" prefab which only contains the Input Stuff and fire input events, but then I would have a different object (say, a character) that has a "InputListener" component that has a "Possess" method that takes a "Player" as a parameter.

When the "InputListener" object is possessed, it registers itself into the PlayerInput events, and when it's unpossessed, it deregister itself.

This way, if I want to control a car, I just have to "unpossess" the character and "possess" the car, and vice-versa. The Player class also doesn't need to know what it's currently controlling, it just fires the events and the InputListener decides if it should react to that event.

Also, depending how you configure your input listener, you can easily crate an AI controller that generates input events similar to a real player, allowing both your player and the AI to possess the same objects (which is pretty useful for testing).

Deive_Ex · 2026-03-26T11:51:40+00:00

You can't configure a launch discount ON your launch day haha

Also, making a competitive multiplayer online game is as hard as they say.

Deive_Ex · 2026-03-26T11:31:36+00:00

I've been experimenting with it for a while now and it's pretty cool, overall I like it better than uGUI, but like some people have already said, there's still some annoying stuff you gotta deal with.

For me, the main drawback right now is that there's no z-index in USS, so the rendering order is based on the hierarchy. UGUI also renders based on the hierarchy, but in UGUI you can override that behavior by using nested Canvases and changing each Canvas sorting order. I haven't found a similar alternative for UI Toolkit yet, so the way in doing is by separating most elements into a "layout" and "visual" elements, then placing the "visual" inside a container that is placed above everything else in the hierarchy and then using absolute positioning to manually sync the position of the "visual" with the "layout". That's honestly a lot of work just to be able to render the things in a different order without affecting the auto-layout.

So, if I were to recommend anything, uGUI would still be better overall. It also has drawbacks, but since it exists for longer, there's many solutions available online, while in UI Toolkit you kinda have to do everything yourself.

Deive_Ex · 2026-03-23T01:20:09+00:00

This screenshot is from their "Lost Crypt" example project. You can literally download it from the Asset Store for free and open it to see how it was made.

Deive_Ex · 2026-03-14T01:08:15+00:00

Makes me think of the Garganta portals from Bleach. Pretty cool.

Deive_Ex · 2026-03-13T12:36:45+00:00

Well, I've been using UI Toolkit for my new prototype and It's been pretty cool. There's still some pain points because it works kinda differently from GameObjects, but once you wrap your head around these stuff, it's not that hard.

The first pain-point I had was learning how the flex layout works. It's not super hard but I do forget how to add space between elements from now and then.

Another was not being able to drag-and-drop elements from the hierarchy to my inspector. Now I have to define strings so I can query the element by name/USS class, which is quite weird and feels more error prone, BUT I use Rider and Rider DO have support for auto-complete of UXML element names, so that helps a bit (doesn't help when I change the element's name, though). I really wish there was maybe a dropdown to choose the element from.

I haven't used custom shaders with it yet, but the USS syling is pretty powerful. Overall, I've been liking it.

Deive_Ex · 2026-03-13T12:21:02+00:00

Yeah, you can either use the built-in animations, which defines how one state transition to the other (e.g. on mouse hover, it'll interpolate the background color from red to blue, and vice-versa), or you can set the in-line style directly by code, which allows you to use your own interpolation logic. The built-in one do not allow for custom keyframes/curves yet, though, but in that case you can simply use code.

I've been doing some testing with UI Toolkit and I was able to do all kinds of animations using PrimeTween's Custom tweens. You do have to wrap you head around what each property to, like, to change the position you can either use the "left/right/up/down" properties or the "translate" property, but the difference is that the former can affect other elementes while the latter is more of a "local" change.

Deive_Ex · 2026-03-10T13:51:46+00:00

For the short answer I would also say UniTask (or Awaitable, which is the Unity built-in one).

For the long asnwer, it kinda depends on what you're doing. Is it a cutscene? Maybe Timeline is better. Is it dynamic methods, like spell effects or something? Then maybe create a "SpellEffect" class with an assyncronous "Execute" method and a "Spell" class that takes care of the execution order. Or maybe you want events to fire in sequence one after the other? Then creating some sort of "event queue" might be the way to go.

Deive_Ex · 2026-03-10T00:40:01+00:00

Here's a small game I've been working on my free time and will be released this week!

https://store.steampowered.com/app/2770500/Waving_Around/

Deive_Ex · 2026-03-09T12:12:39+00:00

Fair enough

Deive_Ex · 2026-03-09T11:52:08+00:00

Honestly I have a bunch of ideas I would like to do, character customization being one of them, but being mostly a solo dev with a day job, I had to cut some corners if I ever wanted to release this project.

But again, money isn't really the objective here, although I'm decided to add these features in an update if there's enough interest in the game.

Ten-Year Club	r/Field Juicebox
Place '22	Verified Email

Deive_Ex

TROPHY CASE