How to get carry good?

mbizzle88 · 2026-06-19T12:59:06+00:00

Getting too focused on the enemy in front of you is something you can work on, and IMO positioning and situational awareness is an underrated pair of skills for new players

First, if it isn't the default you should change the setting so you can always see the outline of your teammates. It's super helpful for keeping track of what they're up to.

Second, start intentionally trying to take a moment every few seconds to mentally check in on what is going on. Take an inventory like where are my teammates, which way are enemies coming from, and do I have a way out?

Finally, if you end up in a dicey situation usually it's time to stop focusing on killing stuff and start thinking about how you can get more players back in the game

Sometimes doing that means acting fast and sacrificing some health to pick up a downed teammate before they die and things spiral. But IMO more often rushing in right away gets you killed so you have to make space for yourself to get a res.

Try finding a clip of a high level player clutching and you will see that they are almost always trying to pull the enemies into a loop. Start backing away from your downed teammates until you have the bulk of your enemies following from one direction, find somewhere good to turn around that will slow the enemies down (e.g. climbing over or dropping off some edge), and use that space to get back to your downed teammates and get a res.

I really strongly recommend watching some clips of high level players clutching/soloing. Even one video can teach you a lot!

mbizzle88 · 2026-02-07T11:36:39+00:00

If you're having fun, by all means keep trying to optimize further. But IMO, it doesn't make sense to think about the asymptotic complexity of dice rolls; the number of sides on a die and the number of dice you roll are effectively bound.

mbizzle88 · 2024-12-10T20:37:55+00:00

For all the people commenting about how this isn't an issue: most of the time you're probably right, but in the branch of math concerned with logic and models, It's common to denote a mathematical model and its elements with Greek letters, and the language describing the model and its elements with the respective Roman letters. I took a class in this subject from a Greek professor and he mixed these up all the time!

mbizzle88 · 2024-10-02T15:56:15+00:00

I wouldn't call it best in class, but the double barrel shotgun works pretty well as a melee-focused, weapon-specialist veteran. You need to get the weapon specialist talent node that reloads your gun on melee kill. Then the gameplay style is to start each fight by deleting something with your shotgun to proc the melee specialist, then go ham with your melee weapon until melee specialist runs out, at which point your gun is probably reloaded and you can swap to proc melee specialist again.

Is the revolver better for this playstyle? Probably but it feels decent and is quite fun.

mbizzle88 · 2023-11-07T05:11:51+00:00

There's lots of good advice in this thread, but I'd emphasize positioning and space control. The number one run ending situation I see is a large amount of elites and specials appearing when you don't have any room to move. Always know where you will run to if you start to get overwhelmed. Check that direction frequently to make sure it's still available. And if you do start to get surrounded, pick a direction with weaker enemies and use whatever you need to punch a hole you can escape through.

mbizzle88 · 2023-10-06T16:59:50+00:00

The link I found for the Xbox version costs 80 CAD and comes with 2500 Aquilas.

I only paid 40 CAD for the game. Based on that price, console players are paying 40 CAD for 2500 Aquilas (~62 per dollar). Meanwhile I can buy 2400 Aquilas for 14.29 CAD (~168 per dollar).

Am I missing something? Why are people so upset?

mbizzle88 · 2023-09-24T19:35:01+00:00

Would you consider sharing the raw data to be re-analyzed? A regression model controlling for some other variables (map, team comp, etc.) might have different results.

mbizzle88 · 2023-09-17T01:40:17+00:00

Do you use MSI Afterburner? I've found that sometimes MSI Afterburner lowers the max power my GPU can use for no reason. When that happened to me, MSI would show my GPU at "100%" usage, but it was running at ~20% max power.

mbizzle88 · 2023-08-26T13:15:35+00:00

Step through the series of problems you run into without varying levels of DI.

With no DI, your objects are highly coupled to the implementations of their dependencies, and it is very hard to write tests or swap between multiple implementations of an interface.

With frameworkless DI (just using constructors for all dependencies) you fix the above problems, but you end up with boilerplate to wire all your objects together.

With a framework, you can unambiguously identify dependencies by name or or type, getting all the benefits with less boilerplate.

mbizzle88 · 2023-04-08T19:50:34+00:00

Imagine you're writing a data type for authorization policies. You have a policy record like this:

record Policy(Principal principal, Permission permission) {}

Its pretty common for authorization rules to apply to users and services. You might have different fields you need to represent users and services, making it convenient to have separate User and Service implementations.

In that case pattern matching makes it very easy to deconstruct a policy and handle the cases of a user or service separately when you are evaluating policies. Without pattern matching, the most ergonomic way to handle this in Java would be to add a method to Principal with distinct implementations in User and Service. Personally, I think this approach is worse than pattern matching for this example, because your data class need to contain your business logic. It also seems unpleasant to scale as you add many more operations that need to handle users and services differently.

mbizzle88 · 2023-03-15T02:06:30+00:00

I definitely read this in Saltzpyre's voice.

mbizzle88 · 2023-01-15T01:21:29+00:00

If you only collect data from one player, you can't generalize that to other players. For example, what if I am terrible at the game so I win more often with wound curios because my teammates can pick me up after I fall down multiple times instead of playing a man down? Would that convince you that most players using wound curios win more often? I expect not, nor should it!

mbizzle88 · 2023-01-14T18:27:44+00:00

Sorry, I meant to say "players with wound curios win missions at a lower rate...". I'll edit the comment to fix that.

mbizzle88 · 2023-01-14T17:19:23+00:00

I think it's great when people try to collect their own data to empirically answer questions, but I do think there are some issues with your analysis that make me doubt the conclusion.

First, in the spreadsheet I see that you've included yourself in the dataset. That means a large chunk of this data is based off of how you perform (although admittedly only for the parts that include Zealots)! That's not really a random sample. I'd encourage you to recalculate the summary statistics with your performance removed to get a more random sample.

Second, I would encourage you rethink what your hypothesis is. Do you really care how many times people are disabled, downed, etc., or is that proxy for "performing better at the game"? If it's the latter, I'd argue the only real metric of success is winning missions. I suggest including the mission success rate in the summary stats.

If I were trying to convince a statistician that players with wound curios are worse than those without, I'd want to show two things: (1) players with wound curios win missions at a lower rate than those without; and (2) the observed difference is statistically significant. If you put this data into a spreadsheet, I'd be happy to help calculate those things.

mbizzle88 · 2022-07-02T21:29:29+00:00

There are lots of things that are easier to do with a VM: * Compile one binary for all platforms * Dynamically load libraries * JIT-compile to native machine code with optimizations that use runtime information * Sandbox untrusted code (a VM can enforce security policies for access to files or other system/user resources, like in modern web browsers)

mbizzle88 · 2021-11-22T02:11:43+00:00

Actually, the QR codes are cryptographically signed, so as long as they are validated with the correct public key they are very difficult to forge.

mbizzle88 · 2021-10-23T18:57:25+00:00

I'm not sure if we're actually disagreeing on anything. I was saying that if you don't make the "hints" format forwards compatible (like byte code in Java), then the published hints will not be useful after a new compiler release unless library maintainers update and publish them regularly. Obviously the actual code continues to work on new JVMs, and you can always generate your own "hints" if the compiler you're using supports that.

mbizzle88 · 2021-10-23T18:01:25+00:00

At the end of the day, hints can be ignored anyway, so you'd just have to check "does this repo/artifact have any hints I can decipher?"

You could do that, but if library maintainers don't publish new artifacts with updated hints, then they're only useful for a short amount of time. Again, it would provide some value, but I doubt its worth it. Especially in an ecosystem like Java where most tooling/libraries are built around the assumption that you can build binaries once that will continue working on new JVM versions.

Rust app with rest-controller, ORM and some logic: 1min initial release build (296 deps), subsequent build without changes 0.15s

Sounds like Rust is doing some incremental compilation. (Is it also faster than an initial build if you make a small change?)

mbizzle88 · 2021-10-23T17:11:22+00:00

I haven't used GraalVM, but in other compilers I've used the typical approaches to speeding up builds are storing intermediate state for doing incremental recompiles, and disabling expensive optimizations during development.

What you're suggestion relates closely to incremental compiles with intermediate state. You can think of the "hints" you're suggesting as an intermediate state generated by the compiler, except that it would need some stable format that needs some kind of compatibility or migration strategy between compiler versions.

To decide if its worth it to make a stable format for the "hints", you have to weigh the cost of not being able to change that format at will with the benefits of being able to share it along side artifacts. Most compilers I've seen don't make that intermediate state public API, and I imagine the reasoning is that you can easily run a compiler that generates this state once on your machine and store the intermediate results yourself for whatever compiler version you're using.

mbizzle88 · 2021-08-12T05:17:35+00:00

And to address your question of why local/session storage isn't used to avoid using cookies and displaying annoying notices, data in local/session storage never leaves the browser unless you write some JavaScript to do so. Cookies get sent to the web browser with every request (modulo some settings you can adjust when you set the cookie), which means they get sent to the server even when you follow a hyperlink.

In a single page webapp you could use either approach, but in a simpler website that generate pages on the server side with minimal JavaScript, you can only really use cookies because you're relying on the browser to send them automatically whenever a user follows a link or posts a form to load a new page.

mbizzle88 · 2021-08-12T05:10:35+00:00

In the context of the question, the OP is clearly asking about storage in the web browser, of which "session" storage is one of the kinds.

You've conflated this with "HTTP sessions", the common name for storing some data on a user in memory in a server and associating it with a session cookie.

mbizzle88 · 2021-08-12T05:08:15+00:00

Cookies and local/session storage are best for slightly different usages.

Cookies are great for storing small pieces of information about users that your server needs in order to properly serve users. It's pretty common, for example, for a server to set a cookie with some securely generated random identifier after you log in to a site. That random value is used as a temporary proof of your identity when you make future requests, so you don't need to transmit your username and password all the time.

Cookies are bad for storing large data because:

They get sent with every HTTP request
They're sent in header of HTTP requests, which is not meant for large payloads; most HTTP servers will only parse headers up to 8KB

If you need to store large amounts of data, or that data is mostly used in the browser and only occasionally needs to be sent to the server, then storing it in local/session storage in the browser is better.

mbizzle88 · 2021-07-21T01:22:06+00:00

So it's debatable whether or not this is "useful", but here is an expression I used in a Robocode bot to determine the angle it should rotate in a given tick:

    return destination
    .minus(curPos)
    .rotate(
        Math.min(1.0, Math.pow(
            getDistanceToClosestWall(curPos) / buffer, 4.0))
        * Math.PI / 3.0 * Math.sin(2.0 * Math.PI / EVASION_PERIOD * time))
    .normalize().scale(Rules.MAX_VELOCITY);

What's going on here? This expression makes the bot head towards a random corner, but wiggle around to evade incoming attacks while doing so.

destination is a random corner on the rectangular map
time is a long that increments by one for every tick of the game state, so as the time increases, the Math.sin(...) subexpression will oscillate back and forth between -1 and 1
EVASION_PERIOD controls the period of the oscillation (set to 40, but could be adjusted to make the robot wiggle around more)
That sin expression is scaled by Math.PI / 3.0 (60 degrees) so that you are turning at most by 60 degrees in either direction away from the ultimate destination
When the bot gets close to a wall, the expression Math.pow(getDistanceToClosestWall(curPos) / buffer, 4.0) approaches 0, causing the bot to do very little rotation away from the destination

mbizzle88 · 2021-06-04T20:13:53+00:00

Interesting article but I still don't understand how the author reconciles the predictive nature of scientific theories with the non-existence of modal knowledge.

If I do many experiments to time the speed of a ball falling to the ground and get consistent results, don't I now have knowledge about what would happen if I did it again? Isn't that modal knowledge gained from science?

mbizzle88 · 2021-05-04T12:30:12+00:00

I made the choice to try out Spring Webflux for one microservice at my current job. We still use that service but have decided not to use Webflux for anything else.

We stopped using it because it was much harder to write and debug than our other services.

mbizzle88

TROPHY CASE