I've created CSGO bots that imitate human movement. I'd like your feedback! This post provides the instructions for the CSKnow play-based user study.
Anti-cheat and cheat developers are locked in a cat-and-mouse cycle of detection and generation. Anti-cheat developers struggle to detect cheating players' behavior. Cheat developers easily evade the detections by generating different behavior. This paper examines how anti-cheat developers may reverse the cycle with configurable hallucinations.
I spent the last five months attempting to implement my prior blog post: training two sub-policies in my bot's behavior tree using imitation learning and deep neural networks (DNNs). The approach was promising because it utilizes standard techniques for outlining bot structure (a behavior tree) and learning sub-policies (imitation learning), while avoiding the difficult question of how to combine learning and structure. In this blog post, I will explain (1) the challenges with this separation and (2) how I may address those challenges with an approach that more tightly intertwines learning and structure.
Reddit users and I agree: my bot's most inhuman behaviors are its combat crosshair control and long-term navigation through map regions. In this blog post, I'll establish the framework for improving these behavior generators. I will explain the types of behavior that the combat crosshair and region navigation controllers should generate, define the inputs to the controllers, and the metrics for evaluating the controllers.
CSGO demo files separately track when flashes are thrown and explode, making it challenging to link the throw and explosion for a single grenade. In this blog post, I'll show that flashbang fuse length is constant, so you can link throws and explosions based on time.
CSGO demo files don't explicitly track player models' head positions. In this blog post, I'll explain an analytical model that approximates a player model's head position based on data explicitly contained in demo files.
My prior post demonstrated the need for CSGO bots that imitate humans and provided a general outline for how to create the bots. In this post, I'll explain my first step toward creating those bots: a non-learned, heuristics-based approach that establishes a structure for the bot. Later work will fill in the structure by replacing the heuristics with Imitation Learning models based on human play data.
I previously demonstrated that my anti-cheat model using aggregate reaction times failed because it didn't account for the context of specific game states. In this blog post, I'll propose a methodology for training "imitation bots" that account for context by imitating a specific human's behavior in a specific game state. I'll also explain how these bots can be used for applications like anti-cheat and coaching.
I previously demonstrated analytics techniques for evaluating players' reaction times and crosshair position options. I attempted to use these analytics to build a wallhack detection model. In this blog post, I'll show that this approach failed because it couldn't account for context-dependent behaviors that enable legitimate players to have seemingly inhuman reactions.
CSGO weapons uses mostly deterministic recoil patterns. However, teaching a human or bot to control these patterns is non-trivial, as actual bullet recoil doesn't match the visual recoil effect applied to a player's crosshair. In this blog post, I'll explain the relationship between CSGO's actual and visual recoil.
Crosshair placement is a crucial skill for expert CSGO players and a key factor in quantitative game sense models. However, learning crosshair placement is hard because it depends on context like a player's location and the map's geometry. In this blog post, I'll propose a way to compute good crosshair placements using this context and Brennan Shacklett's RLpbr renderer, which enables us to GPU-accelerate the computation's ray tracing.
I previously proposed a rough formula for modeling players' game sense. However, I didn't specify how to use the model to evaluate a player's actual performance. In this blog post, I'll propose a way to quantify players' actual behavior in game.
CSGO demos enable players to record and replay games. However, players need to make a choice when recording demos. They can either accurately record only their perspective using a client-side demo (aka a POV demo) or approximately record all players perspectives using a server-side demo (aka a GOTV demo). In this post, I'll explain how to emulate a client-side demo using a server-side demo and a new feature in HLAE. (Thanks Dominik "dtugend" Tugend!)
Online video games like CSGO are distributed renders: many clients and a single server communicate over a network, each rendering their own perspective of the game state. Analyzing these renders' different perspectives can be critical for applications like player behavior analysis. In this blog post, I'll explain the requirements of a logging system that supports analyzing the different perspectives.
Demo files enable us to replay CSGO matches. This seems like a great way to measure characteristics of player behavior like reaction time. In this post, I'll explain my current techniques for measuring reaction time from demo files and issues with demo files that limit the techniques' accuracy.
We've all died to CSGO players who have uncanny game sense. They know all the right angles to peek, the perfect flashes to throw, and never get caught out of position. In this blog post, I'll propose an approach for quantifying game sense so we can identify and study these incredible players.
When taking A site on de_dust2 from cat, you should consider aggressively Ferrari peeking and prioritizing the right half of the site instead of methodically checking the site from left to right. In this blog post, I will use the CSKnow database to show this by analyzing the crosshair placement of ZywOo and other CSGO pros.
I've created a cool data set tracking the locations of CSGO bots every tick for hundreds of games. In this post, I'm going to explain why I created CSKnow, how I created it, and how you can use it.
Let's look at a type-directed approach for implementing image processing applications on FPGAs. This approach will enable us to statically verify a design's throughput. If you like this post, check out my PLDI 2020 paper Aetherling, which provides a formal definition of the types and uses them to make trade-offs automatically during the FPGA design process.
I'm blogging in order to share what I've learned about making programs faster using application-specific techniques.