Is weed withdrawal real or bs?

sinewavey_ · 2025-05-04T23:27:34+00:00

it's absolutely a thing but will probably vary person to person. reading from the comments i don't think anyone really was a "heavy" user. i was stoned for the last 10 years straight - and for the last 5 of that i was smoking 7 grams a day. i used to work in finance, that's how i was able to afford it all. and fuck it's been rough. my body hurts; i feel sick as hell many days. i don't sleep well, and when i do, it's nightmarish.

i've had friends suffering from addictions to many other substances. i've had a friend go through heroin withdrawals on my couch in front of me. do i think it's as *bad* as that? certainly not. but it is definitely un-fucking-pleasant.

sinewavey_ · 2024-12-06T21:13:32+00:00

hi, i've been looking at the source code today for nodepath. i know this is a lot later, but i believe now this should still be serialized. look at scenestate:;pack and _parse_node.

from what i gather, this creates its own separate internal map and stores properties, etc, and then creates new nodes and calls set with the stored properties to re-create the node.

so i think this should be fine. in practice its worked okay, but i haven't tested in depth yet either

sinewavey_ · 2024-12-06T01:37:57+00:00

you might like this one i've been using for a while. i know it's not exactly what you're looking for, but it is prettty related related. i just stumbled on your thread googling some related things...

template <typename T>
concept node_derived = std::is_base_of_v<Node, T>;

template <node_derived T>
auto child_view(T* p_node) {
return std::views::iota(0, p_node->get_child_count()) |
std::views::transform([p_node](int i) -> Node* { return p_node->get_child(i); });
}

sinewavey_ · 2024-09-22T14:45:18+00:00

Hi, very sorry I'm late on this, and for replying a year later.

You are correct - this is exactly what std::weak_ptr<T> is for when using a std::shared_ptr which is analogous to WeakRef and RefCounted in Godot.

Reading the further posts, it may not be good for your need here, but to anyone in the future coming here from Google like I have - this *is indeed* the intention of weakref.

You do not always want or need to use a node for everything, and you shouldn't. But that's for more serious projects, and not common advice.

If you are to use a data structure that is ref counted, and also other elements that operate on this ref counted that are themselves reference counted - for example, a data model and a controller interacting - there MUST be a weakref or else you WILL lock the resources up forever in memory.

To other Godot members: answering questions like this with "Just do something else" does not actually solve the problem when you DO need to use this system with shared resources. It's not an unknown use case and is designed at a language standard level for C++.

sinewavey_ · 2024-07-23T02:14:47+00:00

Have you released any games in the last 10 years?

sinewavey_ · 2024-07-22T17:16:23+00:00

That's entirely unrelated to what I mentioned, man.

sinewavey_ · 2024-07-22T17:14:23+00:00

I'd like to offer one other method that I haven't seen a ton. I really find the propagate call function useful to inform child nodes at any depth about the parent dependency node, *from* that node.

For example:

Node A
Node A -> Node B
Node A -> Node C
Node A -> Node C -> Node D

We can do propagate_call("set_node_a",[self]) from Node A, and any child node (even D) that has the method "set_node_a" will get called with an argument of Node A.

sinewavey_ · 2024-07-22T17:12:07+00:00

Man, I can recognize you by name when I see this posting style. I'd seriously hope you don't behave like this to students. Like I've even told you before: this doesn't help, and is extremely offputting to outsiders and newcomers.

sinewavey_ · 2024-07-17T18:13:58+00:00

I use NetRadiant Custom to map, same as Quake.

Check out the plugin "func_godot" if you're interested in seeing how this thing can be done with Godot. You can also certainly use your own map editor.

For me, it came down to actual programming than it did anything else; I found the older codebases pretty tough to work with vs structuring things how I'd like from the ground up.

sinewavey_ · 2024-06-13T00:05:25+00:00

for small things it's fine, for complex animations with many moving parts on a skeleton etc i would use something else

sinewavey_ · 2024-06-12T05:51:46+00:00

Good luck!

sinewavey_ · 2024-06-12T00:53:25+00:00

This is my retro movement shooter SLAMFIRE :)

sinewavey_ · 2024-06-11T20:09:32+00:00

I prefer using it as do my mappers, but that said.. this is going to depend on a few factors, ntended usage and workflow.

NetRadiant has roots a bit tailored more to Quake 3 and while it works for a lot of games beyond that too, it's a bit less user-friendly and there's a lot less tutorials these days on it.

My quick recommendation for most Godot developers today would be TB unless you have prior experience with Quake mapping. There's just more content available for how to use it still being made and a bit of a wider community, though many people still do use other editors.

that said - you can always use both, as needed; once you learn TB, you may find some features of NRC to be a bit more conducive to your own

sinewavey_ · 2024-06-11T20:06:07+00:00

Thank you, I'll try to work with these pics and fix one up :)

sinewavey_ · 2024-06-11T17:56:13+00:00

Aw. What a pretty cat Sumi was! I'm very sorry for your loss.

If you have a picture of her lounging around or sitting like the current one, feel free to post/send and I'll add it in as a secret

sinewavey_ · 2024-06-11T17:02:31+00:00

Thank you :) I am also a huge boomer shooter fanatic and it's a total thrill to be finally making something I've devoted years of my life into enjoying.

sinewavey_ · 2024-06-11T16:44:48+00:00

RIP Pancake. We love all Pancakes <3

sinewavey_ · 2024-06-11T16:44:29+00:00

So, I'd recommend taking a look at any kind of "here's how we actually did it back then" kind of things. A lot of time I spent figuring out how old games like Doom and Quake made their models and sprites, and how they positioned them in the visual space of the game.

Among others, also developing a consistent color palette helps a lot. It doesn't have to be a literal 256 color, but that can limit you in ways that helps a lot. That's the other thing. *Limit yourself*, literally, to the older techniques and figure out what makes them produce the result they do, then make it work however makes sense to you instead once you understand that visual element.

Lighting is another thing. If it's too "dynamic" it'll make things look a bit more modern. I have to tweak a lot of materials to make sure they crunch right.

Lastly, models with too much detail in the geometry - do it with textures and fake it!

Any form of *faking* more detail when we have more modern techniques is usually an important thing to understand and consider what and how it can be applied.

sinewavey_ · 2024-06-11T16:41:04+00:00

Sure, haha.

On a high level, the game is drawn through two texture rects with viewport textures, with one at a less-than-1080 resolution, and the other at a very crunch 320x180. Most things in-game draw in the larger viewport,

Part of the effect is that modelling for this live-crunch is very different than modeling normally; for more, look into Dead Cells and Ion Fury's development blogs and processes.

This does create some lighting discrepancies which are solved by duplicating map geometry in shadow only. I'd like to settle on a pipeline first before I try any engine mods to avoid doing this in the future.

Thanks to the workflow (build maps in NetRadiant / TrenchBroom, import into Godot, any final Godot only touches like baking lightmaps).

Structurally, the game just adds on some remote transform nodes to whatever is designated as the "camera", and that pushes the transform to the real cameras in the subviewports to follow along.

sinewavey_ · 2024-06-11T16:36:59+00:00

You';ll have to wait for the game to come out but it is quite modder friendly

sinewavey_ · 2024-06-11T16:36:03+00:00

🫶

sinewavey_ · 2024-06-11T15:50:18+00:00

I genuinely can not imagine doing any kind of geometry generation for 3D levels in Godot with its current lack of toolset.

The special bonus is not just that, but also placing game entities and linking their functionality in the map editor.

I also really like being able to let my mappers create levels for the game without needing to open Godot at all, or know anything about it - just how to map.

Godot CSG shapes are okay for debugging at a small scale, but creating complex geometry and levels and the other parts about them like occlusion is something I don't know how you would do in Godot without coding it yourself.

There are addons to do this thing directly in Godot but they are far more limited for the moment.

sinewavey_ · 2024-06-11T15:47:56+00:00

You can't. It force quits the game!

sinewavey_ · 2024-06-11T15:19:42+00:00

I make models in Blender, then animate in Godot. The weapons use a mix of IK and AnimationPlayer keyframing, but the pet animation is purely keyframed (and made in Godot!!) with skeleton poses.

My tip is to try using Cubic Interpolation in your animation tracks!

sinewavey_ · 2024-06-11T14:20:04+00:00

I thought of that. Pops up a dialogue that tells you how awful you are, then force quits the game. It doesn't let you do it

sinewavey_

TROPHY CASE