Advanced target visibility working

GuiltySpark now extracts the map’s BSP and performs ray casting for better detection of target visibility. In fact, it can determine if the line between any two arbitrary points is obstructed by any part of the level (minus the scenery at this point). How I did this is simple in concept: imagine the map as a number line from 1 to 10 instead of a 3D space. Suppose the two points I want to check are 2 and 5. The BSP works by recursively subdividing the space into two halves. In one half we have the set {1, 2, 3, 4, 5}, and in the other we have {6, 7, 8, 9, 10}. Both points are in the first set, so half of the entire map can now be ignored. The next subdivision gives the sets {1, 2, 3} and {4, 5}. The points, 2 and 5, would now lie in different sets and so we stop here. This means that both {1, 2, 3} and {4, 5} may contain a number between 2 and 5 that intersects their ray. As you can see, we can’t only consider the first set because we would miss 4, and likewise for 3 if we only considered the second set. We next consider all the smallest subdivisions of these two groups: {1}, {2}, {3}, {4}, {5}. These are called the leaves and they represent surfaces. Their surface may be located somewhere between 2 and 5, but that doesn’t mean they intersect the ray. Thus each leaf in the range {2} to {5} is checked for ray intersection.

Last night was a total code-a-thon and I ended up writing all the ray-BSP intersection code. I didn’t get a chance to test it last night due to a couple bugs, which I have resolved just this morning 11:50 (morning for me). One bug was forgetting to check if the BSP node child indices are -1. I was already checking if they had their 0x80000000 bit set, which indicates that they are a leaf containing BSP2D references and not another BSP3D node, but an index of -1 says that there is no node at all on that side of the plane. I think this is due to the way Halo creates its BSPs. When building a BSP, it’s difficult to know where to place planes to divide the level properly. I think that the developers chose arbitrary polygons and used the planes they lie on. If this polygon defines the exterior of the geometry at a concave part of the level then there’s a chance the plane won’t intersect any other part of the map and so one side just faces outside the map. In reality, this happens rarely meaning Bungie chose a good heuristic. The next bug was not handling flagged plane indices in surfaces, causing an out of bounds error when accessing my planes array. I’m not sure what a flagged plane index means, but flipping the flag bit seems to have no negative effect.

In any case, the number of flagged planes is probably so low that any problems caused by it would only rarely affect GuiltySpark’s ability to determine if the target is visible or not. Worst case scenario: it shoots at a few walls accidentally. This new method is still a vast improvement over the old target visibility detection. The BSP is extracted in the blink of an eye, so GuiltySpark can do it during gameplay without any hiccups. I thought I would have to read Halo’s memory in large chunks to extract it quickly, but it turns out that wasn’t necessary. GuiltySpark extracts the BSP only once when the target visibility data source is initially requested by the AI, at which point it’s stored internally until you restart the AI. The actual calculations for the ray intersection are fast too. I found plenty of opportunities to prune my options and limit the amount of calculation required.

To calculate if the ray intersects a polygon, I find the point of intersection between the ray and the polygon’s plane. I then project the polygon and the intersection point into 2D space based on the dominant component of the plane’s normal (ensures best topology). The Jordan curve theorem is used next; if an arbitrary ray from the intersection point crosses an even number of the polygon’s edges, the intersection point lies outside the polygon.

So what does this mean for users of GuiltySpark? The bot now knows if a target is visible despite distance and how much the aimbot is leading them. You could also turn off the aimbot when the target is not visible, so no more locking on through walls. All-in-all, this new addition makes for a more believable and human-like bot. With a half-decent AI script, nobody will be able to tell they are playing against a program.

Advertisements

BSP extraction

Over the past while I’ve made a lot of progress reversing Halo’s BSP. Now that I can extract the information, I just need to write the algorithms to work with it. As I’ve mentioned previously, one goal is determining target visibility by checking if any polygon in the BSP intersects the ray between your player and the target. To do this, I’ll find the smallest possible node of the BSP that contains but does not divide the two points. Every leaf under this node will contain potential ray-intersecting polygons.

Here’s what I learned about Halo’s BSPs:


Extras

It looks like I won’t have all the stock node graphs done for release. The maps Blood Gulch, Damnation, and Rat Race have finished graphs. I did some of Hang ‘Em High and Wizard. Freelancer said he did some of Death Island too, so I’d like to include that as well. Freelancer is also going to be making a video showcasing the program’s capabilities. All the documentation is finished now so I’m going to write some more AI scripts while I wait for the video to be done, then it’s time for release!

In addition to the node graphs, AI scripts, tutorials, and example chat file, Halo CE version 1.08 will be included with Version Changer. GuiltySpark is made for 1.08 only, though 1.09 support is something I’ll be adding after release.


No more waiting

Today I’ve been adding a bunch of finishing touches, squashing bugs, and writing documentation and tutorials. Almost everything I wanted to have done by release is done. I couldn’t figure out the vehicle velocity improvement I mentioned earlier so I’m leaving that for later. Player structures don’t seem to store a pointer or object index to what vehicle they’re in.

When I say no more waiting, I’m also referring to busy waiting. I think I finally solved a problem that has been around for quite some time–the program would randomly start hogging the CPU and slowing down itself and the game, even though everything was running smoothly beforehand. I figured it had to do with my aimbot thread. The aimbot needs to keep following a target independently of the AI system. It aims, waits 10 ms, then continues. However, when you want to pause the aimbot then the execution of the thread needs to go somewhere. To avoid creating a new thread every time the AI was started again, I simply looped while a “paused” flag was true. I noticed this took up a lot of my CPU usage, so I added a sleep(150) to the loop which took the CPU usage down but didn’t get rid of the problem completely.

I learned this kind of waiting is called busy waiting and should be avoided because it doesn’t play nice with multithreaded applications. I felt it was kind of hacky from the start anyway. I now use a timer and catch its tick events to trigger the aiming code. I’m not sure how the timer works internally, but I haven’t had the problem since.

Oh, and the bot can type chat messages now. It’ll actually type out entire multi-line files for you in case you want to tell a hundred “Confucius say” jokes to the other players in the server (I may or may not have done this). You can also script it out fairly well by using the $ character, which causes GuiltySpark to wait a second before continuing the message. What’s great is that the chat FID expects numbers for file names and there’s a random number data source. This means you can have the bot select a random message by fiddling with the postfix expression.

Anyway, release soon.


DirectX adopted

GS used to take its sweet time with the CPU when you had the graph view open. This was because it wasn’t taking advantage of the GPU to draw things. Converting the  drawing code over to DirectX turned out to be way easier than I anticipated, and resulting in halving CPU usage when the graph view’s open. I had to learn a bit about the way DirectX expects primitives, then I implemented some wrapping functions to emulate the old ones I had been using in System.Drawing.Graphics. I did have some problems though.

Firstly, the panel control that DirectX was drawing to was flickering. The panel has a bunch of event handlers for clicking and dragging which lets the user zoom, pan, and rotate the graph view. After a long time searching online, I found one person who suggested that a redraw is forced by the panel before the event is raised, which would leave a slight time gap before it is redrawn again. Surely enough, using two panels (using a separate one to draw to) resolved the issue. I just made the clickable one invisible and placed them in the same location.

A second issue was that DirectX only comes in 32 bit. That means GS now has to be 32 bit as well. While it was easy enough to change the build option, it introduced a bug that I didn’t find until the end of the day. Because I was only testing the graph view, the fact that the bot could no longer walk slipped by me. What does walking have to do with drawing the graph? It stumped me at first, then I remembered that I had changed to 32 bit earlier. Little did I know that user32.dll’s SendInput() requires a slightly different argument on 32 bit vs 64 bit. It asks for an array of INPUT structures, but the “type” field at the start of the structure is either 4 or 8 bytes long. When it still didn’t work, I grew pretty frustrated until I finally noticed that my third argument in the call to SendInput was still 40. The third argument is supposed to be the size of the INPUT structure. I made the argument Marshal.SizeOf(typeof(INPUT)), which I should have done at the beginning to save me all this trouble. Lesson learned!


What’s left?

If you’re a member of the Halo community, you’re probably wondering when you can get your hands on GuiltySpark. What’s left? GS still can’t lead targets in vehicles properly because it doesn’t know they’re in a vehicle. This is something I can fix and also expose to the AI system. I’m considering giving the program the ability to type chat messages to the other players even though I know people will horribly abuse this. I’m not responsible for you getting banned from any servers! Perhaps I should add a disclaimer to the documentation. Speaking of the documentation, I have to finish that before release too.

There’s a few things I’ll add after release like 1.09 support, enhanced target visibility detection, and  a full automation mode for server operators (the program will select the right node graph and AI file to use). Source code will become available after release.


On cheating

In the Modacity.net thread, I said I would attempt to stop people from using GuiltySpark to cheat. Because the AI system both accepts keyboard input from the user and controls aiming, it’s incredibly simple to create an aimbot. I suggested not allowing key press detection and aimbot control in the same AI script, but I realize this won’t stop anything…

  • Aimbots already exist, and they don’t have introduced error either
  • People could just use their flashlight, jumping, crouching, or even a shake of the mouse to trigger the aimbot
  • Blocking input might accidentally get in the way of a useful AI script
  • GuiltySpark will be open source anyway; restrictions can be removed

That’s one thing off my to-do list.