tsg heatmapDebug
A script to visualize spawn, death and kill data at the end of each round.
The two variants of the tsg heatmapDebug script serve the purpose of visualizing player spawn, death and kill data at the end of each round. Knowing this data can majorly help out the map creator find out spawns that are being used too much and areas of high death and kill count.
The script comes in two separate variants:
- Lights: Fully realiable and more user-friendly, but costs more budget to place on a map
- Swords: Less reliable with large data amounts and slightly less user-friendly, but costs next to no budget to place on a map. This variant can fit on basically any map.
The script collects the position and rotation of each data point when it happens and stores them in a list. When the round ends, those lists are recalled and an object is mapped to the position and rotation of each data point. The three groups of data will cycle until the next round starts.
To inspect the heatmap data, the Forger must load into the theater film replay of the match after it has finished and navigate to the point in the film where the data groups are visualized. Then the film should be slowed down and eventually paused when the desired data group is shown. At this point the Forger can fly around the map inspecting the heatmap data while the film replay is paused.
Find the scripts here to use it in Halo Infinite.
The other highly budget-efficient variant of the heatmap script was also built in an effort to allow Forgers with maps nearing the budget limits in their creations to still make use of the heatmap script.
The "Swords" variant of the script provides the same functionality as the core "Lights" script, but is less reliable with a high amount of data points due to the script relying on visualizing the data through weapons that are spawned in at the end of each round and then distributed to the data points.
The way this is achieved is by first deleting all dropped items on the map, then teleporting a random player to a dark room outside the map and forcing their aim vector to be facing towards an object that is then given a lot of weapons. These weapons will be used as the data point visualization objects.
A player has to look at the weapons being spawned in, otherwise they would despawn. Once the necessary amount of spawned weapons is reached, they are distributed in the map while at least that one player is forced to look at the direction of the map, in an attempt to not make the weapons despawn.
This method is less reliable than the "Lights" method, as the game might deem the amount of weapons on the map too large anyways and start culling them, which will result in inaccurate data visualization, thus the usage of this variant is only suggested if the core variant cannot fit on the map due to budget limitations.
Development summary:
Script idea
The idea for the script came from wanting to improve I KAMIKAMZE II's heatmap script that worked similar to the core variant of my script, but I saw some improvements that could be made in the functionality as well as the script efficiency.
Research into the efficiency
I put out an open question to some Forgers asking what kind of method could be used for better efficiency in a heatmap script. I got replies from two great scripters who suggested that each data point should be stored in a list and then the entries of the list recalled when it's time to visualize the data.
Initial tests
The first version of the script showed kills and deaths at the same time followed by a showcase of spawns shortly after. This was to make sure the basic functionality worked before diving deeper into the script.
Weapons as data points
After getting the core functionality to work, I explored a way to majorly reduce the object count required for the script. I used a script to give the Energy Sword weapon to a Turret object, which made the Swords drop on the ground so they could be referenced in the script to then be mapped to data points.
Script rewrite
Having done a lot of trial and error followed by botched fixes to the script, I decided to rewrite the whole thing from scratch now with a clear goal on how I'd want it to function. The rewrite took several days, but I was very proud of how it turned out in the end.
First release
After testing both the "Lights" and "Swords" variants exhaustively with bots, I was ready to release it for others to use. I used clever visual boundary tricks on the "Swords" script objects to try to convey to the user where and how the prefab should be placed on the map.
First production tests
I didn't publicize the script more than just mentioning it to my Forge friends even though I had published it for others to use. As the script was in a territory I had not explored before nor got the chance to test it on a large scale to make sure it worked as expected.
Long-term reliability tests
For the entire development of my 4v4 map Titanium I had either the "Swords" or "Lights" variant of the script present during every playtest to test the reliability of the script. It's always funny to see people reacting to the Swords or Light objects appearing on the map followed by people pointing out that it's my heatmap script.