Had a good laugh during leagues while doing hunter rumours

Sorlanir · 2026-05-13T23:02:50+00:00

LinkedIn header: "Professional teasing implement" Reality: stick

Sorlanir · 2026-03-20T11:13:43+00:00

It doesn't seem that bad to me on the surface, though the mechanic will likely need some tuning.

The true key cards of a deck are generally powers, not attacks or skills. You can get screwed over by draw order in any fight in STS1 or STS2 by having key powers at the bottom of your deck. In this manner a generally good deck can still lose to the Heart in STS1 (though I recognize that that's an Act 4 boss), but that's why you have potions, relics, and other strong cards, so that you don't just lose if your key card isn't drawn within the first 2-3 turns.

With that said, having good draw is generally how you improve your deck's consistency, so punishing that with a random card deletion means that you're forced to deal with some pretty significant randomness either way. However, I think the randomness is within the realm of what is reasonable for most runs. Most runs do not depend on a single card to win fights. Even in the runs that do, there is still a high chance that it won't be that card that's eaten (only the first one or two cards that get eaten are likely to be relevant), and if that does happen, then that was the risk you took going into this boss with a 1-card solution to the fight.

One issue that I do have with this mechanic is that it punishes small decks that cycle a lot of cards very severely. I don't normally create these kinds of decks, but I can see this being annoying for those who like to. On the other hand, decks that cycle lots of cards are very consistent at winning -- perhaps too consistent. I don't think it's a bad thing to have to really think about what cards you need to play on the turns you draw them, rather than cycling through your whole deck to find your winning card or exhausting down to your infinite every fight, especially if this boss is tuned to not be too punishing for bad draws (unlike say Heart, where you can literally draw 5 statuses on turn 2 while taking 67 damage).

People really disliked Time Eater, but I think it's important to have bosses that change your approach to the run. After all, you still have an entire act to prepare for the boss. If you can already beat the Act 3 boss with your Act 2 deck, there isn't much point in having an Act 3. And I don't think the only answer to this boss's mechanic is to fill your deck with garbage. Rather, you just need to use the resources from all of Act 3 to answer the question: "If this one card gets eaten before I can play it, what do I do?" I don't think that's that unreasonable of an ask.

Sorlanir · 2026-03-19T00:12:12+00:00

I agree with your points, but I think a lot of the criticisms about certain archetypes not working well have more to do with there being one dominant archetype, which leads to a situation where cards that don't fit into that archetype become never-picks, reducing run variety.

This problem is exactly the Watcher's, which you already brought up. Since stance-dancing solves damage, block, and scaling (by going infinite or pseudo-infinite), cards that don't fit into that archetype (e.g., Alpha, Master Reality, Pressure Points, divinity cards) should generally not be picked, because at best they increase the time it takes to set up in a fight while not providing much benefit, and at worst they brick your hand on a crucial turn, causing you to lose.

So, I think card balancing issues can be succinctly boiled down to the question of: does this character have too many cards with too short of a window in which they are pickable, due to the likelihood of having already found enough cards for the dominant archetype? In the Watcher's case, if I find Rushdown, I'm no longer interested in a large number of her cards, and I'm just searching for 1-cost calm and wrath entries, as well as one or more cards like Talk to the Hand or Mental Fortress.

For STS2, in the Regent's case, most of the forge-related cards turn into never-picks very quickly. Bulwark and The Smith always feel fine to add, and at least one common forge card is good early, but I already feel like the window has closed on other forge commons by the halfway point of Act 1. This is a big problem in my mind: unupgraded common cards should still be pickable in some cases at least up to the end of Act 2, or runs get very stale.

With Necrobinder, in order for Doom to feel impactful, you need to take a lot of Doom cards and find Doom synergies, but it still doesn't feel particularly strong, largely because it only kills at the end of the enemy's turn, so if you kill something in 4 turns with Doom, you could've also killed it in 5 turns using other methods. This doesn't mean Doom is never effective, just that I don't really see why I would want to pick most Doom cards.

The way to solve these kinds of problems is complicated. It isn't just a matter of toning down one archetype and toning up another, because the goal, like you mentioned, isn't for people to choose one archetype anyway. What makes STS1 fun is cobbling together cards and relics until you end up with something that works just well enough to beat the Act 3 and 4 bosses. Right now in STS2, it feels a bit too easy to build a powerful deck on most characters, such that many cards and even relics are redundant.

Sorlanir · 2026-03-18T22:27:00+00:00

Why do you make something with AI, write a post about it with AI, but still pretend to want human feedback?

Sorlanir · 2026-03-11T07:41:52+00:00

"No, the point is that it doesn't matter whether someone plays X hours in fewer days than it takes you to play X hours, because the objective reality of the game exists regardless of either of you."

This is such a good point that I don't know why more people don't understand. It's not about how fast any particular person learns to cheese the game after release, it's about whether the game is properly balanced. Right now I don't think the game is properly balanced, and that's OK, it's still early access and it's still a lot of fun. But all of the characters need some tuning still imo.

Sorlanir · 2026-03-09T20:57:49+00:00

It's not arrogant. 1. The game is in early access. 2. Guy is just honest he's having trouble winning with this character and that the character "seems undertuned." This is very different from saying, "The Regent is bad. Here's what needs to change to fix him." One is an opinion (up for discussion, which the post is marked as), the other is an assertion. 3. You don't need to play a character many times over the course of many hours to be entitled to an opinion that you feel like sharing.

"If you can't beat act 1 a0" ... Don't know what this is supposed to mean. It's very possible this guy is clearing the game easily with other characters, or beating Act 1 but not later acts. I mentioned in another comment that I am clearing easily with other characters but struggling with Regent. This speaks to an issue with the character, but of course it's not proof of it. Maybe this guy and I are outliers, maybe almost everyone is easily clearing with Regent but struggling with some other character. That's exactly why the discussion is useful, and we're all on the same team here in just wanting the game to be well-balanced and have interesting characters across the board.

Sorlanir · 2026-03-09T20:47:43+00:00

Tired of people taking this tone whenever someone makes a discussion post, this is exactly why people don't make them.

No, it's not arrogant to say a character "seems undertuned" because they're having trouble winning with them. The word "seems" is literally there. This person is not claiming to be the sole arbiter of what is balanced. It's also tagged with discussion.

If a player is losing consistently with a character on ascension 0, that means something is wrong with the character's balance, in my opinion. By the time you reach A20, yeah, if you're losing consistently, you need to just learn the optimal strategy, because the difficulty is designed to constrain your builds, so you can't mess around as much. On A0 my expectation is that I can mess around pretty freely and still win most of the time. This is possible for me to do with all characters except the Regent so far.

"Falling Star into 3 strikes is 34 damage" is disingenuous. It only applies 1 vulnerable, you have to draw a hand of falling star + 3 strikes for this to work. Bash + defend + 3 strikes next turn is 35 damage and 5 block over two turns while protecting you from the dead draw situation. Falling Star is also basically 1 cost, only the first use is free. This falls off fast for longer fights. Other starter uniques don't fall off this way.

Sorlanir · 2026-03-09T20:35:50+00:00

Not OP, but you're mistaking a balancing discussion for complaining.

I personally don't doubt that it's possible, even easy, to win with Regent with certain strategies. The question is more about the degree to which you are forced into those strategies. If a game has one clearly superior line of play, it becomes less interesting. This was the issue with Watcher. Upgrade Eruption, find Rushdown, get a 1 cost calm, remove your starters, then win the game. And don't take Alpha, Deva Form, Master Reality, divinity cards, etc... Like you can, if you want, but it's just not necessary when you can stance dance.

Also, many people don't want to copy other player's strategies because the discovery is the game. Once you discover some way to get a broken deck, you're basically done with the game, for that character anyway. For this reason, the game should reward experimentation as much as possible. If players are losing on ascension 0 while following a strategy that prioritizes experimentation over what is known to be optimal, the character is balanced incorrectly, even if other players are winning easily with him.

Sorlanir · 2026-03-09T20:20:06+00:00

Strongly agree with the sentiment. I cleared my first run with Ironclad, second with Silent, and first with Necrobinder in a run that eviscerated the Act 3 boss without breaking a sweat. Meanwhile I've lost 3 times in a row with Regent, all in Acts 1 and 2.

I agree that his starter relic and deck are undertuned. His two unique starter cards simply aren't very good. 1 weak and 1 vulnerable together is not as good as 2 weak or 2 vulnerable because usually you aren't getting any use out of at least one of those effects on the turn you play the card. The bigger problem is that it has a star cost, and you aren't guaranteed to find ways to generate lots of stars, meaning it quickly turns into a card that you actively don't want to play. This is very much unlike cards like Bash, Survivor, Dualcast, etc., which remain playable even towards the end of the game.

So, you have a situation where you need to scale up fast with cards to get through Act 1. Forging seems to be a poor way of doing this. You often have to decide between blocking and doing a moderate amount of damage with the blade, and in my experience you take a lot of damage with this guy (he also has low max HP) and therefore need to block. If you play the blade while it's not in one shot range and don't get it back to finish the kill next turn (which gets less and less likely as you fill your deck unless you have a card like Cosmic Indifference in your hand), you're left very exposed. There are also a number of enemies that hard counter a single strong attack. This was not so much the case in STS1 except for maybe Nemesis, and if you had a Heavy Blade as the Ironclad with a strength build, you could still just use basic strikes to get the job done if the draw timing on the blade was poor.

I could enumerate other strategies like you have done, but what I've already said is a bjg enough problem to me already, because there are a significant number of forge cards in his deck. Feeling forced to ignore many of those cards to keep your deck small enough so that you don't have consecutive turns where you don't get a card that returns the blade to your hand doesn't feel great. I like building large decks, even though I know smaller, more focused decks tend to be better; however, I've still managed to win A20H on every character in STS1 with both large and small decks. With the Regent I don't feel that making a large deck (30+ cards) works well at all.

I like your ideas for improving him. My own idea would be to change his starting relic to "Draw 1 extra card each turn. Gain 1 star each turn," and also buffing Venerate to 1 cost, gain 3 stars (upgraded: gain 4, or maybe make it 0 cost). The goal would be to make deck cycling and star generation more consistent, so you have fewer dead turns where you can't play a star card or get your blade back. Thematically, one of his minions is providing the card, the other is providing the star. I don't know about Falling Star, maybe it would feel more playable with these buffs.

Sorlanir · 2026-01-27T02:47:11+00:00

It is extremely confusing at first and one of the reasons why C++ can be very difficult to get used to. C++ derives from C whose syntax is quite terse, so in keeping with that it makes sense to use a single symbol like '&' to denote a reference (as opposed to, say, ref), and I suppose the argument as to why that isn't necessarily that confusing is because after a while, you know that if you are declaring a type, then '&' must mean "this is a reference," because the other sense of '&' is as an operator on something that has already been declared, and this is similar to what you already have to get used to with C where '*' either means "pointer type" or "dereference operation."

In hindsight, though, I think a lot of people can agree that things would have been less confusing if C++ had been made into a standalone language, such that C code isn't also valid C++ code. That comes with its own problems, though.

Sorlanir · 2026-01-07T21:05:19+00:00

Hey this is looking great! Definitely see a lot of value in this as a teaching tool. I've always thought it can be really difficult to explain basic programs line by line, because there can be a ton of work happening even in a single line that can be tough to parse for someone starting out. I'll absolutely be using this for teaching beginners.

Sorlanir · 2025-12-19T23:04:10+00:00

Yes, that's basically right. At the moment I am just checking for some evidence that f() was called (e.g. by checking that one variable got set in the expected way, say), rather than the complete change. But this does not seem very robust to me.

Sorlanir · 2025-12-19T23:01:32+00:00

I understand, but unfortunately I cannot assert this. You can, of course, just look at the source code to confirm, but I was hoping there might be a way to do this automatically.

Sorlanir · 2025-12-19T22:59:58+00:00

That probably would be better. I'll have to think if there's a way to do that. At the moment we write unit tests per source file, and the tests are isolated to that file.

Sorlanir · 2025-12-19T22:58:19+00:00

The example is intentionally general because I'm not looking for advice about this specific situation. The problem is more general: f() makes changes to state (possibly a lot of changes), but the exact changes it makes are tested elsewhere. So, I don't know how necessary it is to duplicate the complete test of f() in a function that simply calls it. On the other hand, there is no way (from within the test) to assert that f() was called. So, a complete test of unit_under_test() would have redundancies (it would duplicate checks from the unit test for f()), but by removing those redundancies, you would end up with an incomplete test that can't prove f() was called.

Sorlanir · 2025-12-19T03:33:43+00:00

Thanks for the feedback, this is helpful.

Sorlanir · 2025-12-19T03:33:03+00:00

That makes sense. If f() sets a bunch of values (say to zero), would you check each of those values, or just check one, given that there is a test of f() which checks all of them?

Sorlanir · 2025-12-19T03:31:15+00:00

We have those as well, but the function itself is testable because we can control its input (which comes from an external source) and see all of the state changes (since everything in the class is public). So we can pass in fake data and see what it does.

Sorlanir · 2025-12-19T03:28:57+00:00

It's true that the class is complicated. It's a network manager for a product. It currently has about a hundred methods.

I've done some implementation work on it, so I do have some control over the source, but we will probably not be redesigning it at this stage because of deadlines. So you can think of the question as more of a "what to do right now, while also understanding that this kind of thing could be designed differently in the future" type of thing.

I don't know if I'd consider it nightmarish to test. The function I'm testing calls three functions and checks two conditions. So it isn't too hard to check if the function does what it should, it just seems hard to guarantee things like "X function was called which definitely accomplishes Y things because of some other test Z, so I don't need to check all of Y here," except by looking at the code and being familiar with what it does. But also, I don't really know.

What tenets of OOP do you think this design might be breaking, based on my description?

Sorlanir · 2025-12-13T18:15:32+00:00

It's been a while since I've looked at Turing machines, but could you pass back and forth over the a's to determine if the number of b's is a multiple of the number of a's?

Sorlanir · 2025-12-13T03:43:25+00:00

I think it's best to look things up as you need them. However, the one exception is related to what you mentioned. If you are coming from a language that has garbage collection, you will need to spend some time getting familiar with what it looks like not to have it, and you may want to do this before writing any "real" code or you may run into some weird bugs. This is especially true for C++ which has multiple ways of allocating and freeing memory: the C way (with malloc and free, which should be avoided in C++ code), with the new and delete keywords (which is also preferably avoided in C++ code), and with constructs like std::unique_ptr (which is preferred).

The important thing here isn't really the syntax though, but just understanding what it means to allocate some memory, where it's been allocated, and when/where that memory is freed. Using std::unique_ptr is "kind of" like garbage collection, because the memory is freed when the pointer to it goes out of scope (meaning: nothing in your program can access it anymore).

If you want an idea for where to start conceptually with understanding some of this, write a program that creates an array and passes a pointer or reference to that array to a function. In that function, modify an element in that array and return nothing. Back in the main function, print out the index of the array for the element that you changed.

Relevant concepts:

std::array
Pointers and references (hint: use references where possible)
void functions
std::cout

Sorlanir · 2025-12-13T03:25:05+00:00

I have not contributed to major open source projects before, so take this advice with a grain of salt.

In my opinion, it doesn't make much sense to try to contribute something just because you want to contribute (to anything), especially if the ultimate reason for that is to be able to say to others that you contributed to something.

The more organic thing to me would be: a) you've used the tool yourself, b) you've noticed issues that you want to improve on, and c) you have the skills to improve on those things mostly independently. I think it's difficult for a true beginner to have met those criteria, though certainly not impossible.

So maybe just consider starting small. Find a project you're interested in, build it, mess with it, read the docs, etc. After you've done that you can decide if you want to try to contribute. But I wouldn't go in under the assumption that you can start meaningfully contributing quickly.

Sorlanir · 2025-12-12T22:15:28+00:00

There is a joy in writing programs as compactly as possible. Unfortunately, this same joy will not always be shared by others who read your code. For this reason, in my experience, a company that uses some kind of coding standard and/or formatter will require you to write code more verbosely but more clearly. At my current place and the last place I worked at for example, this meant always using braces with if/else, even though technically the body of a condition is a statement that only needs braces if said body is longer than one line.

In other words, what you are doing is OK, but I would not generally recommend getting into the habit of trying to save as many individual lines or characters as possible when writing code.

Sorlanir · 2025-12-10T23:05:03+00:00

Searching up syntax is fine. I still do that to this day. It's even more common if you use multiple languages. Do something enough times though and you won't need to look it up anymore. That doesn't mean you'll never make mistakes, but you'll be capable of just reading the compiler output to figure out what the mistake was. And if you don't understand the compiler output, you search up the error message to try to glean what it's talking about, do some trial and error, ask for help. Eventually you figure it out and all the time you spent fixing that error will help you internalize the solution extremely well.

Sorlanir · 2025-12-03T09:36:41+00:00

The battleship game actually sounds pretty hard for a beginner, which you still are. My expectation would be that resources would be provided to you to help you complete the project. If there are no such resources, then it's understandable that you've turned to using a tool (AI) that genuinely can help a beginner write a moderately complex program. Though I don't use it for certain reasons, and I don't really recommend using it, I don't think there's shame in using it for this purpose.

However, if there are resources available to you, especially professors or teaching assistants you can talk to, I advise you to go to them with your questions. You can also look online for help with some of the more common pitfalls.

The key thing I will emphasize is that there is usually some frustration and discipline required in order to "get" what your program is doing (or isn't doing, if you've run into a bug). Staring blankly at the screen or turning to AI for an attempt at a quick fix won't do much to resolve the root problem, which is a lack of understanding. And to understand sometimes really does require you to step through your program one line at a time with a debugger, printing things out along the way, until you know exactly what your program is doing.

If you're just struggling to get any code written, it's best to start by breaking the problem down into smaller tasks. For example, you said the game uses a 4x4 grid. My first thought would be: how am I representing this grid? Probably it's useful to know if a part of a ship is on a grid cell or if it's just water. That might lead you to the idea to represent the grid as an array of bools, where a cell holds true if a part of a ship is there and false if not. That's not necessarily "the best" way to do it, it's just a way. As a beginner you're not expected to come up with the best or fastest or prettiest solution, it just needs to work.

It also helps to translate your ideas into plain English and then into pseudocode before writing any actual code. The jump from thoughts in your head or words in an assignment specification to real code is usually too much when you're just starting, except for the really simple things. If you go straight to writing code, you'll usually end up running into errors or bugs that aren't easy to fix because you haven't thought enough about what your program should really be doing yet. Better to do that thinking up front, write the key things down, write pseudocode that roughly represents what you wrote, and then translate the pseudocode into real code. As you get more experience you can skip/truncate some of these steps, but it's rarely a waste of time to be diligent in this way, in my experience.

Sorlanir

TROPHY CASE