Cassius Lux

Thanks for stating your bias, that's honestly refreshing to see and I appreciate it. For what it's worth, my work involves writing and training these algorithms and I also do not trust LLMs with anything more important than templating. Given your background as a musician I would like to expand on some context around machine learning algorithms. This has been touched on by others but I'd like to reiterate here. LLMs and generative AI as we know it today are a part of the academic area of Machine Learning algorithms but they do not comprise the whole area. One of the simplest forms of a machine learning algorithm is a regression line on a scatter graph. You can input one of the axis values to this line and make a prediction on the other axis' value, you then adjust this line based on how accurate the prediction was. With that said, I'd like to address the points you've raised, which are all valid: 1 - This depends on the algorithm your using and on the volume of data your using to train that algorithm. Things like KNN (K nearest neighbour) are essentially trained instantly, with the trade off that you need to plot all of your data when making predictions, slowing things down drastically at runtime. The flip side is things like LLMs and generative algorithms where you're 100% correct and possibly being generous on how long those take to train and that's before we get to data preprocessing and cleaning that needs to be done first. You make a very valid point about it needing to be trained for a given combination of mods as that would meaningfully effect the expected behaviours. Limiting the scope of any potential ML anticheat mod to the vanilla game as a proof of concept would, I feel, be a more achievable goal. 2 - This is the great thing about ML algorithms, depending on which one you use and what data you select to train it, it could be that reletively few metrics are needed in order to accuratly flag if someone is cheating or not. We can use things like correlation coefficents and correlation matrixes to search for these variables. Essentially, the algorithm will be looking to aggregate expected player behaviour to a baseline. Once you have that, outliers become strong indicators of behaviour not matching expectations. We dont need to map the entire space of possible action, that would be unsolvable. I'd like to cover your training data point seperately below. 3 - 100% agree, they can be monsters. 4 - This is dependant on the size of the neural network. Small scale NNs can be run locally with barely any noticeable difference in performance, large scale ones however are hungry beasts, some can be run locally on beastly home pcs but the really big ones like LLMs need specialist infrastructure. The main kicker for NNs is their training time. It can take many hundreds of thousands of iterations durign training for it to adjust the weights in the number of layers you've selected. 5a - I'm genuinly curious to know what is contributing to notorius here. During my literature review I wasn't able to find anything indicating that something like this was worse than current industry standard methods, let alone attempted. If you have any material supporting this I'd love to read it! The biggest critque of these methods I found is that they are very data reliant. For example: you can't use this method to slap anti cheat on a game no ones played yet which is the main industry use case. 5b - I went into my thesis with the same expectation, that the algorithms will be fine with most players but will struggle when it gets to high skilled and professional players. It supprised me to find that the opposite was the case, the higher the level of a players skill, the more it conformed to an expected set of behaviours and the easier the algorithms found it to highlight outliers to this behaviour. The issue came from the lower end, players not skilled enough to be even remotely consistant were frequently the subjects of false positives/negatives. Not enought to render the algorithm useless but it definitely degraded performance. Training Data - The algorithms that you would want to use for this problem are classification algorithms. That means your asking them: given this data, what label does it belong to? With this in mind, in order to train these kinds of algorithms you need labeled data, so we would need both normal and cheating behaviours included in this data set. Naturally, there will be more normal data points than cheating ones but you can employ statistical models to balance these data sets without impacting performance meaningfully. One you have this labeled data set, training your chosen algorithms and testing them becomes straighforward. During my thesis proof of concept I was able to get 70~80% ish accuracy using a decision tree algorithm and just 340 data points. This is not to understate the challenge that cleaning, preprocessing and balancing data would present as CS and Vintage story are vastly different games but it highlights that it is possible even with a limited data set. At the end of the day, all these algorithms can produce is a confidence score. What we do with that score is up to us (or more likely the server owner) to decide. You absoloutly can open source some of them as you don't have to use black box algorithms for this. SVM, KNN, Random Forest are all inspectable and you can see what influences their calculations. It's how I learned about the correlation between CS cheaters and weapon clip sizes. 100% this. Something that can help solve this problem is running whatever solution is chosen for anticheat on a seperate service to the server's own. The server shouldn't need to wait for a check or correction before allowing a given state package to be processed, especially when they can be processed in parallel. The server can then be informed if any of these checks flag as cheating and deal with them then. NB: If you (or anyone else reading this) are interested in learning more about machine learning algorithms or data science in general I would whole heartedly recommend learning some programming concepts with python and following the iris tutorial for R. Edit: Updated point and added a remark.

I wouldn't be supprised if this kind of logging/telemetry is already in the game but disabled behind a development mode flag. The player based version control for game state is an interesting architecture idea though. It might be possible to write a comprehensive rule set to cover all the conflict states and how they should be resolved.

Evening all, First time posting and infrequent lurker here so not sure what the drama is (Going to stay happy in my ignorace there thanks) but wanted to give my thoughts as I did my masters thesis on researching machine learning algorithms for an anticheat solution. I'll try to keep to as little technobable as I can but apologies if some terms slip in. Essentially to reiterate what others have already said, you can not trust the client. What other people do with their machines is their business, however, what they send to the server is another story. Things like state management and general moment to moment gameplay data is routine and as it turns out from my research, all you need to be able to detect not only who is cheating, but what kind of cheat they are using. Entertain a shift in perspective for a moment. Instead of trying to prevent a given client from running any number of mods/cheating software, you instead train a machine learning algorithm on what 'normal' gameplay looks like using the moment to moment data sent already as part of normal client server operations. This data can be used to create a baseline of expected behaviour and once you have that, you can pass your moment to moment gameplay data through this trained algorithm to detect cheating players in real time (Section 2). This can even be done asynchronously on another service to avoid adding load to the game server. This creates a situation outside of the whack-a-mole industry standard for anticheat currently. Instead of relying on detection from something running on the client, you're instead comparing the players behaviour with a ML algorithm to an expected base line. These algorithms will typically return a confidence score (percentage) of how likely it believes the data passed is cheating behaviour or not. As a result, you're not playing catchup with very talented programmers who will cercumvent your anticheat, you're instead looking to see if they've behaved in a way that is not accepted. Doesn't matter who's or what cheating software they're using, if the behaviour matches that of a cheater, they'll be found by these algorithms. To take this to the next step, any players who flag with a high confidence score of cheating could instead be put into a few categories depending on the confidence. To pull thresholds and consequences out of nowhere as an example: 95%+ | Automatic full ban 85%+ | Flag to admin for urgent evaluation or temporary ban pending evaluation 70%+ | Flag to admins for evaluation The catch is that in order to have an easy time training these machine learning algorithms you'll need that baseline data. You'll also need it to be labeled so that the algorithms can be trained to know what 'cheating' behaviour looks like and, more importantly. what 'normal' behaviour looks like. The positive side is that this data is ususally collected anyway for error logging and gameplay development reasons and it just needs to be labeled, which if a managed server has a blacklist of players who are banned for cheating could be done by a python script during the data preprocessing for these algorithms. TLDR: Instead of putting more and more effort into the losing battle of preventing a client from cheating, train a machine learning algorithm using data sent as part of normal gameplay use to recognise when someone is cheating. NB: For those interested, my thesis was based on openly available CSGO data and was able to identify cheaters with a 90%+ accuracy when optimising for as few false positives as possible. Some of the algorithms I tested could even identify the kind of cheat the player was using (wall hack, aim assist, etc.). Fun fact: The thing CS cheaters seem to have most in common? They disproportionatly pick weapons with the biggest clip sizes (Barrettas, Bizon, etc)