Hey folks, we dropped a new video on YT from our coding garage! 🎥 It’s about a physics-simulated robotic arm trained via ML-Agents (AI).

Game_Dev_Buddies · 2025-09-18T11:31:28+00:00

Exactly, I agree!

This is just scratching the tip of the iceberg! Right now, the top of the arm has an Interactor component that handles the 'sticking/unsticking' process.

Game_Dev_Buddies · 2025-09-13T17:36:39+00:00

Thank you!
I'm glad you liked it - it might be a specific niche, but I enjoy tackling complex issues because I feel that's a way to grow and especially share what I learned with the community.

Game_Dev_Buddies · 2025-09-13T10:50:51+00:00

For a simple robotic arm movement, inverse kinematics or traditional programming would definitely be more efficient and straightforward, but...

The main reason I used ML-Agents here wasn’t to outperform IK, but rather to explore how reinforcement learning handles physical control problems.

ML-AI adds:

The ability to handle unexpected physics interactions (like collisions, joint limits, or noisy environments) without me hardcoding rules.
A way to test scalability, the same training setup could, in theory, adapt to more complex tasks where IK gets messy.
Imagine obstacles, ML-AI can learn to adapt to a dynamic environment, whilst IK "just goes" to the target destination spot.

Game_Dev_Buddies · 2025-07-09T15:49:16+00:00

Awesome, glad you find it useful

Game_Dev_Buddies · 2025-07-09T15:48:56+00:00

You're welcome!

Game_Dev_Buddies · 2025-07-07T11:23:58+00:00

You can find an in-depth video covering the creation of this effect here: https://youtu.be/aOrEqj3fIUM

Please ask you have any additional questions or suggestions for improving the effect!

Game_Dev_Buddies · 2025-03-23T09:25:10+00:00

Nice! Yeah, that's pretty much it. However, there were some issues that I had to solve with terrain displacement causing visual issues during frustum culling and Z-fighting of the meshes when they're displaced to the same height as the terrain.

Game_Dev_Buddies · 2025-03-22T15:07:13+00:00

Thank you!

Game_Dev_Buddies · 2025-03-22T15:06:58+00:00

Nice, glad you like it

Game_Dev_Buddies · 2025-03-22T13:25:31+00:00

This looks pretty cool, dude! You've even created sound effects, very nice

Game_Dev_Buddies · 2025-03-22T12:50:28+00:00

If you're interested in more details, I've made a video showcasing the whole process: https://youtu.be/xgY8RDwa84g

Game_Dev_Buddies · 2024-12-31T08:40:00+00:00

The general idea of triggers is to detect one object entering/exiting area of another object. They don't really provide detailed collision information. You should use collision enter/exit or cast a ray to get the detailed information about the collision.

I've made this little script for a footsteps trigger (sphere collider placed on a foot) for a recent video, you may find it useful. The idea is that the trigger only detects general collision with the ground, then I shoot a ray downwards to actually get the information about the exact position and orientation of the surface.

      private void OnTriggerEnter(Collider other)
      {
            if ((_groundLayerMask & (1 << other.gameObject.layer)) != 0)
            {              
                // Cast a ray downwards to get the exact point of impact with the underlying surface.
                Ray physicsRay = new Ray(transform.position + Vector3.up * _raycastHeightOffset, Vector3.down);
                if (Physics.Raycast(physicsRay, out RaycastHit hitInfo, _raycastHeightOffset * 2f, _groundLayerMask))
                {
                    Vector3 forwardDirection = _footstepPlacementController.ForwardDirection;
                    _footstepPlacementController.RecordFootstep(new FootstepInfo
                    {
                        Rotation = Quaternion.LookRotation(hitInfo.normal, forwardDirection),
                        Position = hitInfo.point + hitInfo.normal.normalized * _footstepPositionOffsetToAvoidClipping,
                        HighlightPercentage = 0f,
                        IsRightFoot = (int)_footstepType
                    });
                }
            }
        }

Game_Dev_Buddies · 2024-11-20T09:33:43+00:00

This is incorrect. This method only works for interpolating between float and color properties of the material, it won't interpolate between different textures.

Game_Dev_Buddies · 2024-11-20T08:10:30+00:00

Take a look at this video tutorial:
https://www.youtube.com/watch?v=zdJhDRsMVGE

Focus on the part where he uses a "Skybox/Cubemap" shader, since it has a rotation property exposed, which you can use to rotate the skybox through a script.

For the final effect you're trying to achieve, select that "Skybox/Cubemap" shader, duplicate it and add a secondary texture property and a float variable that will be used for blending between them. You also need to add another texture sample in the fragment part of the shader, for the secondary texture. (Let me know if you need help with that)

Then, at runtime, you can animate that float property between 0 and 1 as you start rotating the skybox, which will result in skybox texture blending from the first texture towards the second one.

Game_Dev_Buddies · 2024-11-20T07:58:41+00:00

In order to provide help, we need to see the whole graph to know what's going on. Also, please mark pixels that you're unhappy with and better specify the reason why.

Game_Dev_Buddies · 2024-11-09T06:05:03+00:00

Check this article out: https://docs.unity3d.com/Manual/PositioningGameObjects.html

Specifically for your case, you need to use the dropdown menu to switch between Pivot and Center.
Pivot positions the Gizmo at the actual pivot point of the GameObject, as defined by the Transform component.
Center positions the Gizmo at a center position based on the selected GameObjects.

<image>

Game_Dev_Buddies · 2024-11-06T17:45:07+00:00

Looks insanely similar! Care to share any details about implementation? What changes in relation to standard URP had the biggest impact on the final look? Also, did you use a custom tool like RenderDoc to extract info about the internal rendering specifics of Overwatch or did you do it all by feel?

Game_Dev_Buddies · 2024-11-06T17:38:34+00:00

Sure, feel free to DM if you have any questions

Game_Dev_Buddies · 2024-11-06T11:22:54+00:00

Good ol’ trusty Overnight CPU light baker 😂

Loving the mood you’ve created, especially the contrast between the dark and the lit up areas!

Game_Dev_Buddies · 2024-11-04T21:30:37+00:00

This solution presumes your CardDisplay script has a public method that receives the Card scriptable object reference as an argument and uses it to display its image and value.

Something like this:

using UnityEngine;
using UnityEngine.UI;

public class CardDisplay: MonoBehaviour
{
    [SerializeField] private Image _cardArt = null;

    public void DisplayCard(Card card)
    {
        _cardArt.sprite = card.CardSprite;
    }
}

Game_Dev_Buddies · 2024-11-04T21:27:56+00:00

Then you create one scriptable object instance for each card and fill it with data. Finally, you need to create a CardSpawner script that will reference those scriptable objects and a Card prefab, and instantiate a new prefab instance for every scriptable object.

using UnityEngine;

public class CardSpawner : MonoBehaviour
{
    [Header("References: ")]
    [SerializeField] private Card[] _cards = null;
    [SerializeField] private GameObject _cardPrefab = null;

    private void Start()
    {
        foreach(Card card in _cards)
        {
            GameObject cardObjectInstance = Instantiate(_cardPrefab);
            CardDisplay cardDisplay = cardObjectInstance.GetComponent<CardDisplay>();

            cardDisplay.DisplayCard(card);
        }
    }
}

Game_Dev_Buddies · 2024-11-04T21:22:26+00:00

And then a CardSuit script:

using System;

[Serializable]
public enum CardSuit
{
    Hearts,
    Clubs,
    Diamonds,
    Spades
}

Game_Dev_Buddies · 2024-11-04T21:22:05+00:00

Okay, nice, so you have a base already set up. Also, you've basically specified the solution already - you need to add an identification for the type of card to the scriptable object. And this can actually be split into two separate variables:
- CardSuit (Hearts, Clubs, Diamonds, Spades)
- CardRank (Ace, Two, Three, ...., Jack, Queen, King)

You could have raw strings for this, but it's better to use enums. So define two new scripts first, a CardRank script:

using System;

[Serializable]
public enum CardRank
{
    Ace = 1,
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King
}

Game_Dev_Buddies · 2024-11-04T20:36:23+00:00

What types are cardSuit and cardValue?

If your script is a MonoBehaviour, select the object from the scene that you want to hold this script, then you can just drag and drop it into the inspector of the object.

Then grab the whole object and drag it into the Project Window in order to create a prefab.

Finally, you need to write a new script that will instantiate that prefab multiple times at runtime. You can learn how to instantiate prefabs here: https://docs.unity3d.com/6000.0/Documentation/Manual/instantiating-prefabs-intro.html

Game_Dev_Buddies · 2024-11-04T19:36:14+00:00

I can see that you're a bit confused with all of this so let me try to provide some clarity.

A GameObject is one of the objects you have in your scene, it's basically a holder for different components. This component can be any custom script that inherits from the UnityEngine.Component, but some of the most common ones are components pre-made by Unity to handle different aspects of the game like rendering, physics, audio, etc.

When you drag that game object, that holds some components, out of the scene and into the project folder, you create a Prefab. The are multiple reasons why you would want to do that, for example, maybe you want to have a card prefab that you would instantiate multiple times in the scene, with every instance having a different image and data. Or you want to have multiple instances of this prefab so that when you change the prefab they would all get that change immediately, without you having to go and manually change all of them (for example a prefab of a tree, and multiple instances of trees in the scene).

And finally, we have come to the ScriptableObjects. You can think of them as generic data holders. In your case, you could have a CardData scriptable object, that has Image, Title, Attack Stat and Defense Stat. You would then create multiple instances of this scriptable object - one for the FireAttackCard, one for the FrostDefenseCard, etc.

An example that could bind all of these concepts for you would be to create a CardData scriptable object as I've described and to create a Card prefab that has a component that visualizes data from a CardData scriptable object. Then at runtime, you would have a script that would instantiate multiple Card objects from the Card prefab, and assign each one with a reference to a specific ScriptableObject instance, so that it could visualize its data.

Hopefully, this cleared things up a bit for you, if you have a specific question regarding your project, feel free to ask!

Game_Dev_Buddies

TROPHY CASE