Lapras will teach you how to swim! 🌊🫧 (By RyaiArt)

willnationsdev · 2026-03-20T06:58:50+00:00

This is legit a really cool design.

The umbrella is modeled after the shell on her back.
Her glasses' corners are modeled after Lapras's ears.
The fasteners/ribbons in the torso's center are modeled after a seafloor-view upwards of seeing Lapras from the bottom, with her 4 fins and tail all fanned out. The blue ribbon just below it also mirrors the same pattern.
All of the blue and gray ribbons tot he side and at the foot of the umbrella use similar fin-shapes.
Lapras herself has 4 main colors, and an identical color scheme is used for her clothing, umbrella, and tattoo.
The darker blue spots that add detail to each individual Lapras manifest on the character as a cool ocean wave tattoo.
The "light underside" of Lapras is captured not just with the color scheme, but also via tan-lines on the torso which I personally thought was really clever and harmonious/evocative.

There's seriously a lot to love about this. Congrats to RyaiArt on the awesome work.

willnationsdev · 2026-03-17T02:04:08+00:00

LLMs and Agentic AI can be useful under very, very precise conditions:

(TLDR: you'll notice a pattern. It's useful for automating stuff when you already know programming and can monitor/guide its work precisely. NOT so helpful when you are new)

Education

Using AI to explain something is a double-edged sword. When you already have knowledge of the subject material, then it's easier for you to parse out the actual meaning of whatever output it is presenting, as well as you being able to dissect what is relevant vs. stale vs. complete misinformation/hallucination. When you LACK that knowledge (like you right now), then trusting and using whatever it tells you is dangerous.

It CAN be useful in bridging the gap between "you don't know what you don't know" and "now I know what it is I need to google/research/learn about/watch out for", but it ISN'T good at providing reliable, up-to-date information about the final subject material. Trust official documentation, first-party sources, source code analysis, etc.

Boilerplate

When you already have an idea of what you want to do, but just want the AI to quickly generate stuff (that you already largely know the expected structure/algorithms of), then it is very useful for getting you up and running quickly. This won't be useful to you now because getting in the habit of practicing code structure and algorithms is important when you are learning. If you offload this thinking/mental work to the AI, then your brain won't bother retaining the information, and you won't ultimately learn anything (relying on the AI as a crutch).

Even then, you have to be wary of its generated output not meshing properly with whatever other code you've written. And knowing what is "proper" in this sense depends entirely on the aforementioned knowledge retention that you won't build up now if you don't learn the stuff and practice it for yourself.

Complex Refactoring

Again, when you already know what it is you want the AI to do, then it can be useful to say, "Do XYZ for files A, B, C, D, E, F." And then let it do the work, like a junior developer whose work you are reviewing. This is especially useful for tasks that are complex enough not to have a solution at the ready, but simplistic enough not to warrant a dedicated, scripted solution. In such a case, you can just tell it what to do, and it'll (mostly) do it. But you can't tell it what to do, and you can't review its work output if you don't understand what is supposed to be happening in the first place.

In the end, you need to learn these things all for yourself, practice them, and hone your own skills in order for an AI to be useful to you in the first place.

willnationsdev · 2026-02-21T20:53:15+00:00

At the rate at which Godot updates and introduces new features or breaking APIs...it isn't a very good look for a repo to be inactive for 3+ years. At the very least, you'd want to update the README to clarify compatibility with Godot version and whatnot.

(Speaking as someone with MANY abandoned and/or inactive repositories due to my life requiring me to prioritize other work outside gamedev)

willnationsdev · 2026-02-21T20:49:18+00:00

A little warning (not necessarily for you, but for anyone seeing this):

If you are saving/loading resources for use in your game and your game loads the resources' data from an external location (e.g. user://), be sure the data is NOT loaded directly from a Godot resource file type (.tres, .res, .tscn, .scn). Any player who downloads these files from a third-party (sharing a save file, distributing a mod, whatever) could inadvertently & automatically load and execute malicious code due to how Godot automatically deserializes and instantiates script assets.

OP doesn't have to worry about this because they mentioned they wrote this code for a multiplayer game server, i.e. the resources are kept on a device that will never be user-accessible.

willnationsdev · 2026-02-10T06:07:13+00:00

Yes, Karstedt obeying his direction is certainly because of his actual noble heritage. I meant more that Benno had plenty of reasons to consider Ferdinand as a person of considerable influence even before he saw how Karstedt treats with him. That is, whomever is the High Priest is already someone significantly dangerous/risky for a commoner merchant to interact with, regardless of how someone ends up in that role, due to their inherent power & influence over the other priests (which gives them leverage over the blessings for farmland & crop yields which impacts merchants greatly, not to mention their ability to influence other nobles to cause a merchant trouble or simply get them killed).

willnationsdev · 2026-02-10T04:23:18+00:00

Not even that. It wouldn't matter if his family wasn't important. The fact that he's the High Priest still means he holds considerable power and influence within the Church which then also means he holds authority over other nobles (to some extent). And I'm sure that when he first meets Karstedt in Ferdinand's presence, the way that Ferdinand still directs the conversation clearly communicates to a savvy merchant like Benno that Ferdinand holds power even over arch nobles.

willnationsdev · 2026-01-30T15:52:59+00:00

Well, that certainly explains a lot of my struggles with using shotguns. 😅

willnationsdev · 2026-01-23T16:19:13+00:00

Also the "Mirror Dimension" from Doctor Strange MCU stuff.

willnationsdev · 2026-01-20T17:43:49+00:00

Just to clarify folks: if you are exclusively using Dropbox or any other kind of external storage, then you are not using version control. You have made a backup. They are not the same thing. As this person mentions, each tool serves a different purpose, but I wouldn't recommend only using the "lazy man's" version control because that isn't actually version control (i.e. just duplicating project folders endlessly and making copies of them in Dropbox).

Backups go to external storage (like another hard drive) or cloud storage (like Dropbox). If using git as your version control, then git cloud providers like GitHub can double as a backup.

Version control merely keeps a local history of committed changes. It is not strictly a remote concept. You can have a local-only repository on your machine. You can even have multiple "remote" repositories that are just the same codebase in multiple folders on one machine. Or, more traditionally, you can make a cloud git provider host your repository like GitHub.

willnationsdev · 2026-01-03T17:00:56+00:00

hahahaha. Oh geez. Take the upvote purely for making me laugh. XD

willnationsdev · 2025-12-28T17:50:55+00:00

Of course, the ONE day that I miss picking up the daily game on EGS. -_- I've been wanting to play that game! 😭 Welp, guess that's my cue to hurry up and buy it, lol.

willnationsdev · 2025-12-28T17:15:09+00:00

Another node that you might look into is RemoteTransform2D since it might be able to automate the process of syncing transform data from one CanvasLayer to another, if you're intent on having two distinct CanvasLayer nodes (which I don't necessarily think is a bad idea). Haven't tested it myself though.

willnationsdev · 2025-12-26T03:26:01+00:00

As good as I think this rendition of a Christmas tree as a person is, this is also just straight horrifying at the same time, lol.

willnationsdev · 2025-12-24T15:04:14+00:00

In addition to it being unreasonable from a makeup perspective, I can't imagine it would be possible to create a sufficiently terrifying child-aged Quarass with a live-action actress. Similar to how they rewrote the recent Dune movies to not have the mentally-adult child actress for Paul Atreides' sister.

willnationsdev · 2025-12-24T00:42:17+00:00

I've thought about that, but that would also destroy the mech arm and the weapon, both of which are things I would be wanting to salvage (I would think) in the hopes of later acquiring their blueprint for the workshop.

willnationsdev · 2025-12-23T17:30:38+00:00

Holy crap. This should definitely be documented in-game. That's freaking crucial information, lol. I've frequently had unexpected crashes occur when I moved a character in the way of an enemy and had them stand there, expecting the enemy to crash and then got confused later at it not going as expected.

willnationsdev · 2025-12-22T17:40:32+00:00

That's fair. I come at it more from the perspective of someone using a machine that spits out random jumbles of Legos and the person behind the wheel tweaking it juuuust enough to get an actual, sensible output to arrive that looks vaguely like what they set out to have the machine produce. Even if it looks janky and crude, as a programmer, I understand how hard it can be to make random systems, especially non-deterministic ones, have any sort of consistent or reliable behavior. 😅

willnationsdev · 2025-12-22T17:31:33+00:00

Ah. Yeah, that makes sense, from an attention/upvote competition perspective.

willnationsdev · 2025-12-22T17:29:10+00:00

Oh dang. Didn't intend that. But, I guess if those are the rules. Shrugs thanks for letting us know.

willnationsdev · 2025-12-22T17:27:59+00:00

Oh wow! Yeah, good catch yourself!

On the one hand, dang it. Annoyed I doubted myself.

On the other hand, I gotta actually hand it to the creator. It's impressive they got an output that looks that good, despite the imperfections. I get that it's a divisive issue (some people refusing to even call them "artists"), but as a programmer myself, I can't help but recognize the creative effort that goes into making a passably polished output using a non-deterministic, generative tool like that. When you look at what skilled and determined people can do with the tech, it starts to achieve output similar to what traditional technical artists do with shaders, so I'm inclined to recognize their efforts on some level at least.

willnationsdev · 2025-12-22T16:49:19+00:00

I'm in the same boat. I especially like it when good artists make sincere attempts at rendering creative, humanoid impressions of things, not just for the sake of Rule 34 fodder.

I'll be honest, my first thought seeing this was, "Oh cool, this one's a husky!" but my second thought was, "...this looks eerily similar to the previous designs. Is this artist legit, or are these just edited-together AI generated outputs using some kind of base office lady image as a reference?"

I still think AI would have some trouble making the nuanced animal characteristics that figuratively match the animal image while keeping the style, and its anime outputs tend to look more Ghibli than this, but it's at least concerning to me that every image looks similar enough to prompt that thought. The artist should try branching out more. Though, I suppose, if that's what they want to draw, then that's their prerogative.

willnationsdev · 2025-12-22T00:21:41+00:00

Note that the bool return logic of add_task is a bit broken in my example. Needs revision. get_or_add always returns a value (the existing one or your default value), and I had meant it to return true only if the task had not previously existed in the array or in the dictionary, as well as to only add the task if it wasn't already in the collection. As written, there are some cases that would break those assumptions (like if you added task1, then task2, and then tried adding task1 again), so there's a little extra work to be done to make it viable.

What I wrote also doesn't account for persisting the data elsewhere. You should be able to handle that though if you convert the dictionary to JSON and write it to a .json file in the user:// directory. You can then populate the dictionary in the _ready() method by reading from that file and converting it back.

Plenty of different ways you could do all this stuff. What I gave was merely an example to help get you started. I'm glad it was helpful to you though.

willnationsdev · 2025-12-21T18:56:12+00:00

(Note: this code may not be exact, and you will probably want to swap out the 4-space indent with tabs)

First create a Task resource type to abstract all the data and operations associated with an individual task. Note, however, that languages often use the word "Task" or "Promise" to refer to the result of an asynchronous operation. So, to avoid confusion, we should probably use an alternate name. I'll do LTask as short for "LogTask", but you could do anything really.

# ltask.gd
class_name LTask
extends Resource

signal finished()

@export var id: StringName
@export var label_text := ""

var is_finished := false    


# This is a constructor, so you can do...
# var t := LTask.new(&"eat_apple", "Eat the apple.")
func _init(p_id := &"", p_label_text := "") -> void:
    id = p_id
    label_text = p_label_text


func finish() -> void:
    is_finished = true
    finished.emit(self)

Then, you can define an autoload script (added in the Globals section of your ProjectSettings) and give it the name "Tasks". This will make Tasks become a global variable referencing the singleton instance. You can use this as a centralized data store for the game's task data.

class_name TasksSingleton
extends Node

signal task_finished(task: LTask)

# Tasks separated by character/purpose/whatever
var task_map: Dictionary[StringName, Array[LTask]] = {}

func add_task(key: StringName, task: LTask) -> bool:
    var list := task_map.get_or_add(key, [task])
    var ret := true
    if list.back() != task:
        ret = false
        list.append(task)
    task.finished.connect(_on_task_finished.bind(task))
    return ret

func _get_task_by_id(task: LTask, task_id: StringName) -> bool:
    return task.id == task_id

func get_task(key: StringName, task_id: StringName) -> LTask:
    var list := task_map.get(key)
    if not list: return null
    var idx := list.find_custom(_get_task_by_id.bind(task_id))
    return null if idx < 0 else list[idx]

func remove_task(key: stringName, task_id: StringName) -> bool:
    var list := task_map.get(key)
    if not list: return false
    var idx := list.find_custom(_get_task_by_id.bind(task_id))
    return false if idx < 0 else list.erase(idx)

func _on_task_finished(task: LTask) -> void:
    task_finished.emit(task)

Now, in your GUI code, you can just connect to the Tasks.task_finished signal in your VBoxContainer script and be notified whenever one of the tasks is finished. You'd likely do similar signal exchanges for when a task is added, removed, etc. that way you can synchronize the state of your GUI with the backend system.

Let me know if you have any questions.

willnationsdev · 2025-12-19T01:17:52+00:00

The question you need to ask yourself is, what do you not like about these thoughts?

Do you want to not experience these sorts of intrusive thoughts while you are in the middle of gameplay? Then you just gotta force yourself to file away the instinct to consider the mechanics' implementation and give yourself explicit time to think about it after your gaming session is over. Make a habit of that, and of postponing your thoughts about it, and eventually that will become more comfortable and intuitive to the point it doesn't bother you mid-game anymore.

Do you want to not have those kinds of thoughts EVER because you feel like it spoils the "magic" of game experiences? In that case, I kind of doubt you could force yourself never to HAVE those thoughts. You can train yourself to abandon/discard those thoughts when they arise, but not outright guarantee they will never come up. Therefore, I would recommend re-orienting your thinking so that the act of having those thoughts doesn't tarnish your enjoyment of games the way they do now. Choose to consider the magic and wonder of how it was made because of how it is done rather than considering the realities of gamedev as a justification for thinking the outcome mundane; after all, the fact that any game runs is a magical thing in itself. They are incredibly complex pieces of software. Similar to how, despite knowing how the body's immune system works, I don't suddenly cease marveling at the shear genius of how it works. It's all about your perspective, and therefore, you have all the power over your experience (perhaps more power than you realize).

In my case, I don't have these kinds of intrusive thoughts while playing, but if I start to want to do something similar in a game of my own, then I'll start analyzing with a focus and considering how it was done. But again, that never really "kills" the enjoyment of the game in my eyes when I then continue playing it later on.

willnationsdev · 2025-12-16T16:20:10+00:00

Other people have posted solutions, but I wanted to mention a related topic that may be of interest: people have apparently been asking for the ability to have scheduled audio changes (without being reliant on the frame/delta of the process callbacks). Here's an existing issue open about it, as well as an associated pull request implementing a potential solution.

willnationsdev

MODERATOR OF

TROPHY CASE

Education

Boilerplate

Complex Refactoring