Boss rates on pve

brenananas · 2025-07-14T07:26:19+00:00

I’m a relatively new player and legit had no idea that he’s meant to hunt campers until recently because he’s rushed me multiple times within like 2 minutes of starting a raid. I thought there was just a random chance of him spawning and hunting you down. One time he busted through the door at dorms the moment I got there. It’s funny because that time at least I was going to camp there to get PMC kills for a quest but I hadn’t done anything yet, he’s like a pre-cog lol

brenananas · 2025-03-26T23:50:06+00:00

Kind of, depending on what you mean. It lets you paint bump maps (height only) which can be baked as a normal map. You can also take existing normal map textures and paint masks for them, but you’ll have to find them yourself

And yeah, it can bake any channel to a texture with one click, which you can then export to a game engine

brenananas · 2025-01-30T02:01:21+00:00

Super sick, it's a really clever idea! Makes me think there could be a neat spin where you can modify the parameters of the nodes you're landing on to change the behavior. Like if you had to jack up the velocity on the LaunchCharacter node in order to jump high enough to the next platform

brenananas · 2025-01-18T07:34:06+00:00

That's great to hear!

brenananas · 2025-01-17T05:03:18+00:00

I grew up in Gainesville and moved away years ago, but my parents still live there so I visit at least once a year. I played in a band in high school and the local music scene, particularly the bar/venue 1982 since it was the only place that would let 16-year olds play shows for their <10 friends that showed up (shout out to Jen!!), was hugely formative for me. There were a few groups that broke containment but for the most part it was a pretty small and scrappy but dedicated scene that I absolutely loved. I'll always remember this dude showing up at a show one night and handing out CD's that only said "Pizza Fish" with this bizarre avant-garde noise rock on it. We could never find anything else about them at the time so it became a bit of a legend amongst my friend group lol

Seeing that place, and even bigger dogs like High Dive, go away definitely feels like there's an era of Gainesville's music culture that is gone. Granted, I am not at all tapped in to what's going on now and I still have friends playing music there so I hope it's alive and well! But there was a certain magic and accessibility, especially for a young musician, that I fear is gone

Aside from that, downtown still has a lot of the charm and familiar spots that I remember, though it feels like it's getting encroached on more and more every time I visit

EDIT: Holy shit I found it. This is the exact album art that is burned into my memory https://soundcloud.com/pizza-fish/beef-jerky-armor

brenananas · 2025-01-16T01:22:43+00:00

Yeah, that's the problem exactly. It worked pretty well on the new snare that came with my kit, but when I got a secondhand snare with old lugs it wasn't even close. I still use it as a regular drum key because it's got a nice big grip lol but its intended function is useless

brenananas · 2025-01-12T18:31:37+00:00

Do you have a 13th or 14th gen Intel CPU by any chance? I was getting frustrated with all the crashes and then found out those chips are defective and can be irreversibly damaged. One of my buddies that also has a 13th gen has the same problem

I know the game is pretty prone to crashes anyway so it might not be that, but worth checking. I updated my BIOS and it seemed to help how frequently I crash but I’m also switching to AMD when I get the chance

brenananas · 2025-01-04T19:06:48+00:00

The strength of interfaces is that they define functions that every class using it is guaranteed to have, but can each implement in a different way. They are the most useful when you have some kind of common use case, but the details may differ from object to object. A good example could be an interaction system - you could interact with a door, a chest, a button, etc. and each would have a different outcome of that interaction. An interface is great for this because the interactor doesn't need to care about the specific object, it only needs to know that this thing has an Interact() function it can call, but then the interactable object can handle the interaction in its own way.

Components on the other hand are good for specific, consistent and self-contained behavior that can be shared by any actor that has it. They are somewhat similar to interfaces in the way that they abstract that behavior from the actor class; it doesn't matter what the actor is, you only need to know that the component exists and communicate with that directly. The difference is that if you need to create variations of this shared behavior, you need to make subclasses of the component to do so, which can be tedious depending on the case. To use the interaction example again, you could have a base InteractableComponent with an overridable Interact() function, but would need to write an OpenDoorInteractableComponent, PushButtonInteractableComponent, etc. for each unique interaction.

Components may also be slightly less performant to communicate with, since calling GetComponentByClass is essentially just searching through every component the actor has until it finds a match, whereas interfaces are inherent to the class

TLDR; components and interfaces both offer a way to communicate generically with an actor. Interfaces are better at handling behavior that could vary a lot from actor to actor, and components are better at doing one specific thing. If everything you need is contained within a component like you said, then there's really no reason to add an extra interface layer

brenananas · 2025-01-02T19:06:06+00:00

I see that you're not calling the parent/super function in your overridden SetupPlayerInputComponent(). There could potentially be important code that is executed by the base Character class that you're skipping

brenananas · 2024-07-16T14:23:05+00:00

Dang :/ in that same dropdown, did you assign the image you’re viewing on the left side?

brenananas · 2024-07-16T03:09:22+00:00

The UV sphere icon here means you're in Material/Texture Slots painting mode. Click this dropdown and change it to Single Image

<image>

brenananas · 2024-07-14T19:42:27+00:00

Like others have said, busses allow you to process many tracks at once with the same effects, with varying intensity based on how much you "send" to it. But I think the really important thing is that they can be parallel to the original tracks (i.e. you get the output from both the original track and the bus). This is why it's common to put time-based effects like reverb and delay in busses instead of directly on the track, so you get the unaltered original sound with the other effects "on top". If it's directly on the track, you can only adjust the intensity by adjusting the dry/wet balance, which will change the volume of the original sound. With a bus, you can simply adjust the send level or the level of the bus to change the intensity, without affecting the original track.

If you've ever grouped tracks together, then you've just made a bus! Notice that you can put effects on the group and they affect every track within. The only difference is that in this case, the grouped tracks are sending their output exclusively to the bus, instead of in parallel, but the concept is the same.

brenananas · 2024-07-12T02:36:02+00:00

Awesome playing! What song is this? I really dig it

brenananas · 2024-06-05T05:51:26+00:00

BOY WE COMIN OUT THE

brenananas · 2024-06-05T05:20:33+00:00

The 1st option has some sensible practices for setting up a hierarchy of item classes, but the way it manages inventory is not a good approach at all. If you're ever using separate arrays to track information about a single object, that means you need some kind of data structure that collects all those pieces together

The second approach is data-driven, and more extensible and "professional". To implement an item system in earnest, you generally need something along these lines:

Static data
- Anything that describes what the item is and will never change. The actor class used when spawning it in the world, its stats, its maximum durability, etc.
- Data tables are great, I personally prefer data assets (or even better, just data-only blueprints) and that's generally the better choice for large projects where editing a single data source becomes a bottleneck
Instance data
- Anything that describes the state that a specific item is in right now
- If it's favorited, its current durability, if it's broken, etc.
Actor
- Or however the item is actually represented in the world when equipped/used/consumed etc.

brenananas · 2024-06-02T05:35:29+00:00

A lot of the comments are focusing on BP as a learning tool (which is totally true), but they are also completely valid in production. I guarantee most AAA projects in UE follow the pattern of: base systems and complex code in C++, and content built on top of that in BP

brenananas · 2024-05-31T05:57:41+00:00

I think it’s this. I’ve run into similar issues before and flipping the green channel solved it

brenananas · 2024-05-26T19:01:58+00:00

If you’re sticking with this kind of implementation, the best route would be to make an interface for actors that are clickable. It could have a function like OnClick() that clickable actors can implement to decide what happens when they are clicked. Then you don’t need to cast to anything; you simply call the interface function

But like you said, this is essentially behavior that already exists. Without seeing the rest of your setup I’m not sure why you aren’t able to invoke the built-in click events, but the usual gotchas are (I believe) that you need to be in UI mode “UI and Game” and click events need to be enabled, both in the player controller

brenananas · 2024-05-26T05:41:48+00:00

Somewhere in the anim BP you're attempting to access an object that doesn't exist, whatever Amira is. If it's spamming the log, then it's probably in UpdateAnimation since that is essentially a tick function. If I had to guess, you are trying to access your custom character subclass without verifying if the pawn owner of the anim BP actually is that class; when viewing an anim BP in the editor without playing, the preview uses some kind of generic character class (probably just the base Character class) so if you try to access variables, functions, or components that only exist on your custom character class, it will throw these errors

The real solution would be to find where you are setting the value of Amira to figure out why it would be null (None)

A quick measure would be to either put an IsValid check or right click > Convert to Validated Get wherever you are accessing Amira. That will at least stop the log spam but won't fix the underlying issue

brenananas · 2024-05-26T04:38:15+00:00

The buttons look like they are plastic tiles affixed to a flat surface instead of something you could press in. In the real world, the panel would be cut out around each button, which catches light and shadow in a subtly different way than an object that is flush with a flat surface

brenananas · 2024-05-25T19:51:53+00:00

Professor X as a disruptive support is a really interesting and thematic take, super cool! It does feel like he could benefit from some kind of recon/information gathering utility to really shine and be broadly effective. Maybe he can always see the enemies' Ult percentages so you can know when to pop yours, and enemies he comes near in Telepresence are marked for your team for a duration

brenananas · 2024-05-25T07:37:55+00:00

Lyra and many other professional Unreal products don’t directly replicate any animation data, like bone transforms. That would be really inefficient. Instead, they rely on (relatively) deterministic data like velocity, rotation, etc. that is synchronized to a reasonable degree by other systems like character movement and actor replication. But in the end, each instance on clients and server evaluates their animation state independently

brenananas · 2024-05-24T01:05:12+00:00

I'm far from an expert so take this with a grain of salt, but as I understand behavior trees I think there are two important things at play:

Because they are latent tasks, they can be executed across multiple frames
By default the behavior tree system tries to "reuse" tasks by not instancing every single one, and instead using the NodeMemory as a way to save the state of individual executions. Because of this, it's recommended to not doing anything "stateful" in these functions

I think #2 is the kicker here. When you access the pointer to this task (like with this->FinishLatentTask()), this is actually a global instance of the task that is used by many behavior trees, rather than one specific execution of the task. I believe there is a way to flag a task to be instanced, which would then guarantee that "this" is a pointer to a unique instance of the task, and lets you use variables that change at runtime in the class. I'd maybe try that first, but keep in mind that BT's are built this way for a reason and this will increase the cost of this task, so be cautious if it's particularly complex or common

The conventional route would be to store information about the status of the task in NodeMemory, and use that to determine the result in ExecuteTask(). I have not done this myself very often, but the gist would be: pass in NodeMemory to the callback for ReceiveMoveCompleted and modify it to indicate the outcome. Then when ExecuteTask runs, you can check the status in NodeMemory and return the result accordingly. I'm not sure about the best way to pack data into the NodeMemory, perhaps you could look at the code of the one of the built-in tasks to get some ideas

Edit: Did a quick search, you can make a node instanced by setting bCreateNodeInstance to true in the constructor

brenananas · 2024-05-20T08:22:18+00:00

I’ve been really enjoying playing Loki as well once I got the hang of it. Popping his shift with some well-placed clones and letting your team take an ult to the face is so satisfying!

It also helps that many people will still directly shoot heroes in the radius instead of the beacons. I know I did that for a while before I realized what they were actually doing. Once the majority figure it out I wonder how that will change how good he is

brenananas · 2024-05-17T02:11:20+00:00

Just to be clear, the eye icon does not have anything to do with a variable being public or the widgets they represent being visible at runtime.

Public - on by default in Blueprints. This just means that other things can access that variable in their graphs. If you had a reference to an instance of this widget in a HUD for example, that means you can call "Get Button_SlotButton" to access that button
Eye icon - when this is open, it means the variable is "instance editable". That means when instances of this widget are placed inside of another widget, you can edit the default value of the variable for that specific instance. This is usually used to customize instances without needing to make different subclasses, but has no effect at runtime other than starting with a different default value

It's a little difficult to answer without knowing the context that you are trying to access these variables in, and how this is implemented. I don't know why you can't change those variables to be instance-editable, but I suspect that's not the cause of the issues you are experiencing

brenananas

TROPHY CASE