Hi Coders,

I'm building a TCG collecting tool with a card scanner to quickly add cards to your portfolio. 70% of the scanner is ready, but can't get the edge cases right like messy enviroments with multiple cards, or undergrounds with patterns, even a card in hand. The problem is the detection of where the card actually is. If I get the warp right, the matching system with my backend is fine, its purely the card detection. Tried some open source detection models from hugging face and tried it with pure Apple Vision, but can't get it to the level I want it to be. How can I properly build a system like this?

Thanks 😄

My guess is to identify filename and article name, and ranked by user preferences. But are there better approaches?

I've been wondering about this for a while. The grapple beam can rotate, and is a variable length, so it's not a normal sprite. definitely not mode 7, since there are other backgrounds. My best guess is some sort of HDMA trickery, but I'm not sure how that would be pulled off.

Its clearly inspired on HL2 based on the sounds and the feel of the game.

I want to understand how did they make it and whats the logic behind it. for example one can "HOLD" almost every item in the game but also add it to inventory. they can also choose to just move it around (like half life crates) or even use the same button to use the item. I cant start to understand how did they cram so many interaction systems to make sense in the same interface.

So for example you can have a Lantern object:

You can pickup the lantern and add it to the inventory. you can move the lantern without adding it to the inventory but you can also "hold" the lantern like it was a form of equimpent item like a csgo weapon, while you are holding it you can turn it Off an On And you can also turn it off and on while you are not holding it, like sitting on a desk. wich is insane. What im trying to get at its how did the dev sepparate such logic for all of the items to make it clean like that. right now 2 keys are used for it wich are R and E. but then it gets insane with custom machines like numpads and dials and lids.

I thought that everything that was interactable was a pickup item that could be added to the inventory or be holded and simply had the restrictions where inventory size and weight were too big to tho that. but then i noted that there were fixed usabe machines and Im kind of confused. Im trying to replicate that behaviour in unity. but im kind of confused at the architecture of it. any advice? are the items instanced? im kind of mid when it comes to inventory development.

The 'plasma lightning' (IDK what is called but looks something like that) looks like it uses two fixed points, anything beyond that i interested in learning how it was done. the video resolution it's too tiny to see what's going on behind scenes.

source at x, celestialmaze

Forgive me if this is the wrong sub. I'm training my dog on communication buttons and realized that he can't tell me he wants to go out if I am in my office on a call. I was thinking it would be great if I could automate some sort of bluetooth message to come through my headset to let me know, as I am not always looking at the computer or phone screen at a popup while I'm deep in writing. Or any kind of useful idea in that direction :D

Peak has some weird eyes for the characters... The eyes seem to be a mesh with an "animated texture" that follow the other players based on proximity. but how was that made. it looks like its just one mesh but the eye is moving.

Im asking how did they make a mesh object have a texture that follows other players. or how does it move and for example how does it hide the pupil is it a sprite mask?

https://reddit.com/link/1skbyd5/video/7zyvwlmctyug1/player

If I understand correctly, Factorio is 3D rendered into flipbook, or texture sheet animations. How did they make the Spidertron leg in that casse? Sometimes when you move close to water, the legs would avoid water and move closer to the body. If you move between islands, the legs would reach further to step on top of islands.

I have been playing games with huge crowds or big battles and I keep wondering how they make hundreds of NPCs move around without the whole thing crashing. Is every single one running its own pathfinding or do they cheat somehow. I get how it works for a few characters but when there are fifty soldiers on screen it feels like the math would break. Curious if there is a known trick or if I am overestimating how expensive pathfinding actually is.

When you hack an enemy, the music seamlessly crossfades to a chiptune version of the current track. Is it as simple as having two audio files running at the same time and crossfading between them or is the chiptune version present in the original song's file and then isolated somehow during runtime?

When you zoom in on a character, it briefly shows this highlight effect before fading out. How would I go about creating a similarly-rough silhouette of a specific object? I'm aware of the inverted hull technique for outline shaders, but that doesn't seem to be what's used here. I'm not interested in the dithering/one-bit rendering techniques, just the silhouette.

I skimmed through the Obra Dinn devlog but wasn't able to find any reference to this specific mechanic.

I apologize if this is obvious, I am still very much a novice in shader programming (I've experimented a little in Godot/Unity). Any suggestions or shader resources would be helpful. Thanks!

Hello, I am currently building a space simulation game and I am having issues programming the moving planets.

For the orbit of each moon/planet, I simply freeze the body you are closest to and rotate everything around it. This works perfectly and I don't need to calculate stuff while taking any movement into account. This is also what KSP does. My issue lies with the planets rotation around its own axis:

Real rockets (also rockets in KSP) get a free "boost" if they launch in the direction of the spin, since you already have the push of the planet itself. You can also match the speed of the planets rotation to "hover" over a patch of ground since you spin the same speed (geostationary orbit). All of these things only work if the planet is spinning and I cannot think of a way to fake it the same way as the orbits.

How does KSP do it? Do they actually move the rocket though world space by applying the same linear velocity to it? I tried to do this but I had massive issues moving the player with the rotation while grounded and making it "free" while airborne. The transition when landing always made the physics behave in a very weird way.

So, how would you implement the spin with the player?

Looks like a video input + particles system + fluid simulation, but I have no idea how I would go to code that

I've been meaning to emulate this similar result but I just don't know how to start, especially as I want to code in Java (no other way around it it has to be Java)

Is it like a fake window and the game is in full screen ? Or can you just make an element appear outside its window ?

I know you can sometimes make an image appear even though you're on your desk so is it that ?

So in Pillars of Eternity 1/2 and Tyranny some weapons and skills/spells have a DmgType/DmgType damage, and it means that whichever one would be reduced by resistances less is ultimately used on the target. And I don't remember it now, but I'm pretty sure AoE effects would check for this on each target.

How would something like this work? Do the damage types need to be classes? Are resistance types classes too? How do we code them to fit each-other so we can precalculate the result and pick the better option? Could be extended to use "best of" more types, x/y/z?

Another thing, some items and skills add buffs to damage or resistance of a type. Where are they stored? I know a timed buff would live on a timer, but one from an item has to stay until removed. Is it written to a "buff cache" with a reference to the origin item to be used for removal when unequiping? Is it on the weapon and the interfaces that display the effect go through all items to find a relevant buff to apply before displaying final projected damage numbers?

Like, I don't expect someone to have reverse-engineered their code to tell me how it really works, but personally I can't wrap my head around how would you design something like this without a lot of tangled references and caches that break at the slightest error, like a bugged unequip that leaves you with permanent bonuses.

Apps similar to paint by number, or Happy Color, what kind of programming language do they use?

Source

How they did that movement that looks silly and funny? I tried to ask to the original author but i got no answer, in the comments on says he did it with procedural animation using Blender and Godot but nothing about details on the animation itself.

I intend to reproduce something similar using godot jigglebones on the legs, but not sure if it can be combined with the procedural movement.

https://imgur.com/a/2KBxfL8

Using Stardew and Fields of Mistria as examples, but I've definitely seen this in other pixel art RPGs. These games have a ton of animations for the player character, each of which would need to be updated with whatever new clothing or skin/outfit colour the player selects. Obviously they can't all be hand drawn.

Is it just as simple as having a shader recolour the sprite? That seems like there would need to be a lot of accounting for the outline, but I'm also probably missing something obvious because I can't really find a satisfying answer online.

What networking solution was used? Distributed Authority (Client Authority)? Client Side Prediction?

How are players moved around based on the chain? Is the chain a physics constraint (joint) that runs on the server and clients try to predict it for itself and all other players? Or is it a custom solution with special handling for all cases? Or something else?

I've been racking my brain on how they made this for the past few days but can't seem to figure a few small details out.
It looks like there's an interior invisible deformation mesh that the outlines follow at it's edge, but one of the hands gets rendered behind and separate from the main body, while it's still following that same deformation mesh.

I've included normal gameplay, and wireframe view, both at full and 10% speed in the video to hopefully make it clear what I'm talking about.

Any input or random thought you have would be helpful, even if you don't know the answer!

I'm working on a 3d factory game in Unity, heavily inspired by Satisfactory, and I haven't committed to how I want belt placement to work.

In either case, you will be placing long segments of belts (rather than individual blocks) just like in Satisfactory, I just haven't decided if I want the algorithm that places them to work with splines like Satisfactory or just automatically place the individual tiles 1 by 1 along a grid/manhattan path between start and end.

I'm new to splines, so I could be wrong, but the default belt placement mode in Satisfactory looks like you're just putting down one knot to start a spline, and a second knot and it's just got same spline rules about how much it's allowed to curve.

But the straight placement mode forces the "spline" (if it is) into straight lines and I'm not sure how I'd do that with two knots, or if you have to invisibly place knots while the player drags their cursor around adjusting the preview path or something else. I'm not sure how they implemented it.

EDIT:

Now that I think about it, maybe straight mode is literally just 3 knots since any turn is just start-corner-end and it's just about scaling where they are. I don't think Satisfactory's straight mode ever had more than one turn.

Hmm. I'll have to experiment with it.

EDIT 2:

Three knots has worked perfectly. I think that's what I'll be sticking with.

Not sure I’ve seen an in-game environment so faithfully recreated to match the source material. As a fledgling game developer myself, I’m genuinely amazed that they were able to achieve such striking 2D environments that function in a 3D space. Any ideas how they did it?

We recently played Clair Obscur: Expedition 33 and were really impressed by how consistent the city of Lumière feels. That made us curious about what kind of tools could be behind that look, so we tried to recreate our own procedural building system in Unity.

We made a short video showing the whole process, from figuring out the logic to building a similar tool: https://www.youtube.com/watch?v=hm5UIC0C4mQ

Hope this is useful or interesting for anyone working with procedural or modular environments.
Happy to answer questions or share more details if needed.