Roborio/VersionHistory

1.2.7 - 09.04.2017

RoboRumble ‒ APS: 84.77% (21st), PL: 1125-30 (22nd), Survival: 94.55%

• Rolled back the flattener, added a less smooth flattener on top of the existing one. This change doesn't affect this release because it was in DC trees.
• Went from DC to VCS surfing. Did some tunings on the flattener switch condition, seems pretty good. Fixed some issues with it that was preventing the bot from doing well against HOF.
• Fixed a huge bug which would make the second wave relevance greater than the first wave relevance.
• Fixed a bug which would make my MEA be reversed (inconsistent direction value in different parts of the code).
• Went from the naive iterative wall smoothing to a self-coded, non-iterative, pythagorean wall smoothing. Hope it has no bugs.
• Improved shield. Now I can catch bullets from bots I couldn't in 1.2.4, but still... there is room to improve.
• Tried to tweak it against Ascendant. Had very little success on it. Wondering how the top bots can beat it by a good margin.

1.2.6 - 09.03.2017

RoboRumble ‒ APS: 82.24% (46th), PL: 911-32 (211th), Survival: 92.78% - skipped pairings

• Rolled back to True Surfing, but still incorporate other changes from last version.
• Change the moment I retrieved stats to surf. I was retrieving it the moment the wave was fired. Now I do that in the moment of surfing, considering its position in the surf queue.

1.2.5 - 09.03.2017

RoboRumble ‒ APS: 82.53% (44th), PL: 917-31 (205th), Survival: 93.21% - skipped remaining pairings

• Not confident enough about it, but trying a new GoTo code. Changed the flattener a bit as well.
• Try something different on shielding.

1.2.4 - 08.30.2017

RoboRumble ‒ APS: 86.14% (11th), PL: 1136-18 (16th), Survival: 94.92%

• Probably worse version of EnergyDome's VG array bullet shielding. It's not 100% right yet. Only an experiment for now, I pretend to come back to it later and/or try something different. For the next few releases I'll disable it so my movement changes are not masked.
• Thanks to Xor and Skilgannon. They helped me a lot through the process of making this work. Bullet Shielding Suffering is the new Wave Suffering. Ironically, what almost drived my insane was that I had a bug in my movement predictor getNewVelocity() function, which made me miss my next tick position by a fraction.

1.2.3 - 08.29.2017

RoboRumble ‒ APS: 85.76% (13th), PL: 1139-15 (14th), Survival: 95.01%

• Incorporate the changes of 1.2.2b, with some additional tweaking, be a bit more conservative.
• Try harder to improve against aggressive opponents and problem bots. Improved a lot against close-fighters, but still have a bit to improve against rammers.
• Add enemy heat tracking to improve firing detection. Now I won't surf 219840128319 waves against rammers.
• Surf enemy waves 2 ticks before fired using heat tracking and bullet power prediction.
• Changed the flattener a lot. It was hurting my score against rammers and close-rangers, since I would turn it on oftenly against them. Now it will not turn on against close-rangers, since I used the average distance of an enemy as a criterium to turn it on. Changed the weights as well, but clearly it's not well-tuned yet. Need to focus on this in the next releases.
• Fixed a bug where I would set my maximum velocity to zero when breaking as a surf option and would go for the fallback movement in the next tick, without rolling back my max velocity to 8. This was hurting my score against close-rangers, but not that much against rammers.

1.2.2b - 08.29.2017

RoboRumble ‒ APS: 83.77% (28th), PL: 1073-12 (70th), Survival: 94.13% -- missing pairings, had no patience

• Shoot bullets bigger than enemy's bullets when my hit rate is high.
• Changed the way I pick my base bullet power.

1.2.2 - 08.28.2017

RoboRumble ‒ APS: 83.28% (34th), PL: 1113-12 (38th), Survival: 91.88% -- missing pairings, had no patience

• Fixed a bug which logged the guess factors for bullet-hit-bullet events incorrectly.
• Fixed a bug in my precise predictor that was causing my precise MEA to be completely wrong.
• Use DC movement with a lot of trees (around 13 of them). I introduce you the real SlowBot.
• Fixed and enabled the bullet shadowing algorithm.
• Mark a wave which contains a bullet-hit-bullet event as a safe wave, making it possible to surf further waves earlier.
• Tried to do better against aggressive bots, my movement was really bad in this matter. Tests were made based on GrubbmThree, Predator and DoctorBob. There is still a lot to improve in that matter, though.
• Refactored some of my movement code since there's a lot in common between GoTo Surfing and True Surfing. In this process there were really small changes in the movement logic as well.

1.2.1 - 08.25.2017

RoboRumble ‒ APS: 77.88% (82nd), PL: 1127-27 (21st), Survival: 88.38%

• Tweaked both guns, improved slightly in both AS and RM challenges.
• Changed a lot my VCS segments, though it was gonna improve in the Rumble since the previous movement was not good at all. It seems that I should have tested it more.
• My score is gonna get hurt by this changes, and since I changed three things in total, now I'll have no idea if the changes in my gun where good at all. Lesson learned: test well your changes before going to the Rumble or submit small changes.

1.2 - 08.23.2017 - the movement minor version

• RoboRumble ‒ APS: 80.41% (57th), PL: 1075-35 (67th), Survival: 90.16%
• Good APS leap, but my PL worsened a lot :(
• Here starts my series on improving my movement and testing everything I can.
• Now that I have all the thing re-written, I tested simple VCS and DC.
• Decided to stick with VCS True Surfing for now, even though I'm planning to try all the combinations (DC/VCS/NN) - (GoTo/True).
• It's hella easy to transition between DC and VCS in this version of the code.
• This version's VCS works on top of 100 randomly generated slices, which turned out to give a initial good result (so much better than hand-tuning). I maintain/access all these slices traversing a Trie structure and creating the buffer for a given segment only when I really need it.
• Expected to have a improvement over the majority of the bots of the Rumble (those which doesn't have adaptive targeting systems), and probably it will do worse against the others.

1.1.4b - 08.22.2017 - the joyful release

• RoboRumble ‒ APS: 76.95% (84th), PL: 1126-26 (21st), Survival: 87.88%
• I just had fun in this version. Tried targeting with Neural Networks. Had coded it before in Python, it was fun to code it again from scratch, without the NumPy thing. Used a simple MLP with no hidden layers, cross-entropy cost function and Softmax activation, even tough i tried sigmoidal functions too. Still not sure if I'm doing the thing right, but I just assumed I was and moved to the training part. That was my main struggle: even with all the info provided by Darkcanuck open-sourcing his ideas on Gaff, I was not even able to pair up with the weakest version of my AS DC gun, so I assumed my NN was not that right and put it aside for some time.
• Full rewrite of all the movement classes, just to make it more similar to my gunning classes. Now my code became less painful to work with.
• In the process of rewriting, tweaked some things that seemed to be wrong and started coding a 2-wave true Wave Surfing movement on top of kd-trees. Visually it was just perfect, but as soon as I tried it out against some strong bots I was like: "How come my GoTo style movement, which I haven't touched since I've uploaded my first version to the Rumble, can outperform this by a enoourmous margin?". At this moment I was shocked, and decided to work hard on my movement in the next versions, from the simpler (true surfing) to the harder (GoTo style), taking account precise intersection, distance controlling, wave weighting and all that stuff.

1.1.3 - 08.17.2017 - the big release

• RoboRumble ‒ APS: 77.76% (80th), PL: 1134-16 (16th), Survival: 88.94%
• Tweaked my AS gun over the Anti-Surfer Challenge and my general purpose gun over the RM Targeting Challenge.
• I haven't event touched the movement from 1.1.1 until this point, which is cool.
• Besides tweaking the weights, I changed the way I simulated decay of data in my AS gun: instead of decaying by a rolling depth-like approach when querying the kd-tree, I stored many trees with decreasing size and increasing relevance, making recent data to be "counted more" than old data.
• In this version I create non-firing waves every tick and log them all when they break in all the trees, making no distinction if the enemy was hit, if it was a firing wave or if it was virtual. Probably gonna toy with that soon, it doesn't seem right, but I'm tired of DC and gunning. Let's try something else.

1.1.2 - 08.16.2017

• RoboRumble ‒ APS: 73.36% (119th), PL: 1107-43 (41st), Survival: 84.29%
• Started doing a ton of tweaks on my general purpose gun.
• Tried WaveSim and genetic algorithms tuning to make my gun strong, but had no considerable result, so reverted back to my hand-tuned weights.
• Finally introduced a precise wave-robot intersection algorithm.

1.1.1 - 08.16.2017

• RoboRumble ‒ APS: 72.16% (126th), PL: 1098-52 (49th), Survival: 82.86%
• Started firing big bullets against rammers, how come I forgot about that.

1.1 - 08.16.2017 - First appearance on the Rumble

• RoboRumble ‒ APS: 70.36% (150th), PL: 1011-100 (117th), Survival: 79.71%
• Introduced a very simple (in terms of weighting information) GoTo DC surfing movement. I thought it was really bad at first, but I decided to focus on my gun for the next few releases and when I finally touched it at 1.1.4 / 1.2 I realized it was incredible for my second release. It made me reach top-100 in 1.1.3 with a 98%+ PWIN, which is amazing.
• My gun was just a regular at this point.
• Introduced a kd-tree power selection algorithm, like in DrussGT.
• Started doing a massive refactor at this point so new features are more plugable.

1.0 - unknown date - not in the rumble yet

• Used a self-made kd-tree for a very simple Dynamic Clustering gun.
• Surfed using simple VCS true surfing while keeping the buffers on a Trie.
• At this point I had dozens of classes to keep my code clean and more pleasant to work with, like GuessFactorStats, Segmentation, KdTree, BackAsFrontRobot, MovementPredictor, geometry classes, smoothing utils and many other things. If it was not that, I would probably restart another robot from scratch before going insane. I can't work too much time on a bad maintained code, it's like building a giant (snow)ball of shit.

Zero - 07.22.2017

• Started implementing the robot. Struggled a lot with VCS-based GuessFactor Targeting and Wave Surfing, following the steps of the tutorials, trying to look at the code only when stuck. I looked many times, though :P
• Struggled even more with Precise Prediction.
• Wrote tons of classes and thousands of lines of code 'til the first release. Proud of that. Never been more productive in life.
• Code is pretty modular, though I don't want it to be like XanderCat nor EvBot. I would say I've modularized it "just enough".