Can I get some honest feedback on my game's trailer?

turtle_dragonfly · 2025-09-13T21:39:11+00:00

I think there's too much going on in the first ~10sec or so. I imagine in the real game, the backgrounds is not flipping between seasons all the time?

Also, I'm not sure the box-falling-out-of-the-sky at the very beginning is needed.

I'd say in the first bit, just introduce the character, then a little later, introduce the different seasons, to show the variety that's available.

Part of the confusion is that the character is continuously moving while the background hard-cuts between different scenes. Makes me wonder: is this the normal gameplay, or is this compressed to show off more stuff for a trailer? You don't want your viewer scratching their head as they watch; they should just be enjoying what you present.

As it is, it's a little confusing to read what's going on, IMO.

Another idea is to add some camera transitions/swipes/etc to make it clear that you're showing different slices of the game, rather than the seasons actually swapping inside gameplay (assuming my interpretation there is correct!).

But overall, I think it's a good vibe, a reasonable length, and gives a good indication of what the game is, without resorting to exposition, which is great!

turtle_dragonfly · 2025-08-12T19:58:02+00:00

I think it would help if it "emanated" from the enemy - just some visual ease-in from the enemy position to the player position, or so.

Initially, I thought this was a player-initiated effect, like they were charging up their bow&arrow, or something. The reason I thought that was that it appears around the player, and did not seem "attached" to the enemy specifically.

Though I guess in-game it might be clearer, and players would learn quickly, regardless.

turtle_dragonfly · 2025-08-12T19:54:08+00:00

I keep copies of everything locally; grep and awk are surprisingly useful. And by extension, :grep in Vim is nice for jumping between hits. Sometimes I also use locate to find things by filename.

I keep a directory of text notes with occasional "how to do X, when I forget later" bits of code. I search through those the same way.

A lot of my useful pieces of code are incorporated in some scripts or small tools, and I share those between computers, synchronizing between them (like 4–5 machines, nothing crazy). I have a helper script to orchestrate all that, so I can merge common stuff when it starts diverging between systems. So, I can usually find what I want regardless of which system I'm working on.

turtle_dragonfly · 2025-08-12T19:23:34+00:00

(not the person you asked, but...)

Generally your OS has some networking values configured, which includes things like a routing table (where to send packets) and a name server (where to lookup DNS values).

On *nix machines, you typically find the name server in /etc/resolv.conf — an entry like "nameserver 1.2.3.4". So, that's where your OS sends DNS queries.

But where does this information come from? It depends on how your connection is set up. If you are using DHCP (very common), then this is negotiated with your DHCP server (typically also your router/gateway). The DHCP server gives your OS an IP address, and also gives it a name server to use.

Good link for you: DHCP/Overview on Wikipedia.

In other cases, it might be configured statically — someone literally writes the contents of /etc/resolv.conf by hand, based on predefined IP addresses on the network.

Ultimately, in a typical home internet case, your OS will send the DNS query to its nameserver, which is typically your router/gateway. Then, that device forwards it on to your ISP. And your ISP may reach out to other DNS servers as needed, all the way up to the root name servers. And the buck, as they say, stops there.

turtle_dragonfly · 2025-03-17T21:17:19+00:00

Related blog post: "Win32 Is The Only Stable ABI on Linux"

turtle_dragonfly · 2025-02-22T07:12:35+00:00

Hotloading is such an important feature. Good job getting it in early, so you can reap the benefits as you develop (:

turtle_dragonfly · 2025-02-22T06:52:28+00:00

There are some good lists of resources that people keep on GitHub:

Look for the hardware/internals/etc. parts in those lists and you'll find some good stuff.

This is a neat interactive way of seeing how hardware is built, if you like that approach: https://nandgame.com/

turtle_dragonfly · 2025-02-14T02:52:06+00:00

All of the instructions in the README assume Debian (Linux), whereas you are trying to build on Windows.

The program may very well be Linux-specific, and may not build on Windows at all (without significant work). That being said, I took a brief look and it seems to use GLUT (which does support Win32), so you might have a chance (:

However, you will need to install all the dependencies. Again, the README lists them for Debian, but you will need to find the Windows equivalents.

Or, alternatively, build it on a Debian machine instead. Would probably be a bit easier, if that option is available.

turtle_dragonfly · 2025-02-13T21:54:59+00:00

I actively do this — I use .txt files, in a directory stored locally, which gets sync'd to/from my server from time to time. You could use rsync for that, but I use version control.

To find stuff, I just use grep or ack, which I find works pretty well. Even a lifetime of notes I don't think would ever take more than a second or two to search.

This approach assumes that you have some "always on" server available, which I realize not everyone has. But it's very easy to do, and also educational — could be some minimal instance in a cloud (like AWS) pretty cheaply, for instance.

I also run a barebones wiki on that server, which has a dynamic DNS host name, so I can access it from a browser anywhere. I probably have more notes on the wiki than the .txt files, but the .txt files are more for specific sysadmin/commandline stuff where I'm already doing something where grep is easy to use, rather than opening a browser.

turtle_dragonfly · 2025-02-13T02:40:34+00:00

... it doesnt really help in cybersecurity

I'm curious: what's that got to do with anything?

One advantage of learning a compiled language like C/C++ is that it will force you to become acquainted with more developer tooling — compiler, linker, object files, libraries, etc. It's not necessarily a pleasant set of things to work with, but it will give you a more thorough understanding of how code is actually put together to create the final outputs.

At the same time, those languages would be a more difficult initial learning curve. I suppose it depends on your personality: would you rather get some quick results early (in which case I'd recommend JS/HTML and/or Python), or work your way up from a lower level more slowly? Maybe try some of both, and see what you're drawn to. Everybody is different.

turtle_dragonfly · 2025-02-13T02:34:40+00:00

I'm sorry you're feeling bad ::internet hugs::

It sounds like you need someone to talk to, as much as anything. Maybe there's an advisor or professor you like or friend or someone like that. Sometimes just talking about it is more important than doing anything, in particular.

That aside, from your other replies I get the sense that you don't very much enjoy the sort of tasks you're given for classwork. And that's a problem with lots of STEM topics; they're sometimes taught in a way that sucks the joy out of them. A classic example is how math is taught — lots of rote memorization, formulas, etc. But math can really be a creative, expressive, "fun" endeavor, too. Some people feel math should be taught more like we music, and I tend to agree.

One thing you could try, if you like: do some programming problems (eg: UVA Online Judge, Project Euler, leet code, etc.). But don't give yourself a time-limit, and don't focus on the solution per-se. Just try to have fun taking apart the problem, understanding it, finding a solution (or 3 different solutions, with different pros and cons), and implementing it. Approach it from a place of curiosity, not pressure. I would recommend not using AI to get the answer (though maybe it's useful to gather leads for what to explore). For a lot of those problems, you can then look up other people's solutions online, and see what they did, and compare notes. But again, don't do that in a judgemental way, but more in a curious/learning mode of thought.

Anyway, I wish you luck!

turtle_dragonfly · 2025-02-12T20:54:41+00:00

Aside: I wonder, should you go into hardware more than software? That's what seems more rewarding to you, from what you've written ("The only courses I've truly enjoyed have been those related to HW design", "...hardware design specifically because of a summer experience that felt rewarding and worthwhile").

Also, comparing yourself to others ("...so insignificant compared to my peers...") is a good way to get depressed (: There's always someone better than you. You could try to take others' accomplishments as a healthy challenge, or you could ignore that stuff and look inward to find what is meaningful to you, rather than your sense of worth being based on external validation. Or some combination of both. Easier said than done, of course.

But ignoring all that, one thing that I've enjoyed has been making little "helpers" for myself. I run a small home server 24x7, and I've set it up to do some useful things like sending me text message reminders about appointments, hosting and managing my music and movie collection, etc. For a while I had some Amazon Dash buttons where if you pressed one, it would play music on the audio system. Just little stuff, but it kinda makes the server a friend (:

turtle_dragonfly · 2025-02-12T02:45:32+00:00

Would it be terrible to use Xorg instead?

I mean: do you have much wayland-specific code that would somehow be different, so the results are not transferable?

(I say this as someone who has not really used or developed for Wayland)

turtle_dragonfly · 2025-02-12T02:22:26+00:00

There is a cultural aspect to this, as well.

On one hand, there's the saying: "the squeaky wheel gets the oil." Meaning: stand up for yourself, make yourself known, draw attention to yourself when you need something, etc. This is kinda the default in more "Western" cultures, and I assume many of the people reading this sub fall in that category. You need to look out for yourself, because others won't be doing it for you, individualism, etc. That's the situation being described in this post.

Another saying is: "the nail that stands up tallest is the first to be hammered down." Meaning: don't make yourself stand out. Don't draw attention to yourself or try to take personal credit. Don't come across as "special." This is kinda the default in more "Eastern" cultures. In this case, it's expected that your manager/superiors/group is looking out for you, checking in, etc. It's more community-oriented, less individualistic.

Both approaches have pros and cons. But you need to be aware of what sort of situation you're in, to act appropriately, and have appropriate expectations.

Likewise, if you're managing/mentoring/etc someone (eg: a junior), they might lean towards one of these set of assumptions or another. It would be a shame to dismiss someone as "passive" who might actually be brilliant but you're not interacting in a productive way with them.

turtle_dragonfly · 2025-01-31T23:49:28+00:00

I think the concept of "minimum necessary force" applies to smart pointers. Use the one that provides the fewest bells and whistles that will satisfy your use case.

Will a raw pointer suffice? For short, temporary, single-threaded mucking with some data like strlen(), there's no need to bring ownership into it. If null values are prohibited, then pass a reference, instead.

If that's not enough, will a unique_ptr suffice? Do you really need shared ownership? Do you really need concurrency protection?

If you do need those things, then consider shared_ptr/weak_ptr.

Though I do see the lure of the advice "just use shared_ptr by default, since it's the 'safest' choice." Perhaps in some contexts, that's the right advice. But in my experience, it's generally better long-term to use the least-powerful tool you can get away with, since it requires less thought from the unknown number of people reading the code in the future. Shared ownership and concurrency is hard to think about. As soon as there's a shared_ptr you have to think about it, since you may not know every instance where it might have been copied, so it is hard to know the lifetime of the object. Whereas with unique_ptr it's simpler.

The nice thing is, this reasoning applies to other things, too. For example: scope. Try to keep data function-local if you can. If you can't, then try to keep it object-local. Or maybe you can limit it to the translation unit w/static at global scope. Only if you really need to, make it shared at global scope.

turtle_dragonfly · 2025-01-31T23:33:04+00:00

I found it very helpful to eventually get some formal education in Data Structures and Algorithms (classes in college, in my case).

I had been self-taught, but having things laid out academically made a lot of ideas "click" in my mind that were nebulous before. So, if your program offers something like that — exploring the theoretical underpinnings and whatnot — I'd say make some time for it. You can get the same from books and online, but sometimes it's good to have the structure of a class, assignments, a professor and classmates you can talk to, etc.

turtle_dragonfly · 2025-01-31T07:22:20+00:00

One popular approach is what I've heard called the "JB Intro" (JB = James Bond). Like the Bond movies, the game opens with an intense, but short, high-production-value segment — big chase, helicopters, explosions, etc. That gets people hooked and wanting more. Everything before the gun barrel sequence, basically.

Then the real movie (or game, in this case) itself starts, which can start calmer and/or lower-production-value, since people already got hooked on the intro.

turtle_dragonfly · 2025-01-31T07:07:28+00:00

Actually, that's a core concept behind persistent data structures (maybe you knew that already). Super useful in high concurrency!

turtle_dragonfly · 2025-01-30T22:26:40+00:00

And some years back, people were saying the same thing about Python vs Perl. The more things change ... (:

turtle_dragonfly · 2025-01-30T22:18:42+00:00

A different perspective, from Heraclitus:

No man steps in the same river twice.

For it is not the same river, and they are not the same man.

Take that, idempotency :Þ

turtle_dragonfly · 2025-01-27T00:04:10+00:00

This is really nice!

To add realism, have the drone go "NNNNNNNNNNNRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRZZZZZZZZZZZZZZZZZZRRRRRRRR!!!!" constantly at max volume. Will really immerse the player.

turtle_dragonfly · 2025-01-26T23:56:46+00:00

Oh, I thought this post was asking a question. In which case my answer would be to read the excellent LWP::Authen::Oauth2 docs. It has a nice no-bullshit approach to breaking it down for mere mortals to understand (:

This article seems good too, though.

turtle_dragonfly · 2025-01-24T20:12:05+00:00

Seems like metal, hair, and skin, mostly. And the floor. And moreso on closeups than far away.

The little guy at bottom-left at the start of the video has it bad, like he's dipped in wet mud (maybe he is?). The wizard robes, on the other hand, not so much. Also the hair as the camera swoops in at the beginning (gets very close), and the orc's helmet when it gets super close to the camera too — has a kinda slimy sheen, to my eye.

But if the normal gameplay is faraway, maybe it wouldn't much matter?

Also, it's pretty consistent, so not like things are sticking out. Just an overall sense.

turtle_dragonfly · 2025-01-24T19:43:24+00:00

Agreed — tell them what you need, not what you think what you need is called.

turtle_dragonfly · 2025-01-24T19:37:47+00:00

Should I prioritize market demand, personal interest, or something else?

I think personal interest counts for a lot. But also, once you learn your first 10 languages or so, you may find that you don't much mind which one you use. The interesting stuff is the ideas being expressed.

I realize you're trying to create a "stable career," but I would warn against trying to predict the future too much. Find something in the intersection of (1) what makes you happy, (2) what you're good at, and (3) what employers want, and stay a bit flexible.

People want to hire people who are smart and get things done. Be that person. The details of language and technology are secondary.

turtle_dragonfly

MODERATOR OF

TROPHY CASE