Medina/VersionHistory

Planned series

any future release

• Try incorporating Knight 1v1 movement into it to test if it is better.
• Try incorporating Knight 1v1 guns into it.

2.0 series

• Surf disks instead of circles.

1.3 series

• Try a hybrid between melee surfing movement and 1v1 surfing so the data acquired during melee is used as a strong fallback.

1.2 series

• Maybe use it as my random gun in 1v1 + the adaptive gun.

1.1 series

• Enable bullet shadow.
• Add bot shadow.

1.0 series

• Re-weight MR/WS.
• Try programmatic parameter tuning.

0.6 series

• Add a fallback movement to avoid being cornered and to be in a good position to surf at round beginning.
• Add fallback stats (HOT and LT).
• Do a round of optimizations to turn it into a faster bot.
• Improve bot-width intersection.

0.5 series

• Tune gun parameters.

0.4 series

• Tune surfing parameters.

0.3 series

• When a fire event occurs, examine carefully which enemy could be the target (possibly a probability distribution estimation).
• When a hit event occurs, examine carefully which enemy could be the target using the previous calculated probabilities.
• Handle bullet-hit-bullet event.

0.2 series

• Tweak MEA and bandwidth?
• Improve fire-and-hit detection and use enemy interpolation everywhere (apply hard OOP here).

Latest releases

0.3e - 10.20.2017

• PENDING
  • Get enemy position at the time the enemy was shot (instead of at the time the hit occurred) when evaluating the probability of a robot being targeted.

0.3d - 10.20.2017

• MeleeRumble ‒ APS: 0% (401st), PL: 0-0 (400th), Survival: 0%
  • Try traditional MEA everywhere.
  • Make melee surfing cluster size = 10 and ratio = 1.0.
  • Weight scans only according to distance to targeter and double-weight this instead of triple-weighting.

0.3c - 10.20.2017

• MeleeRumble ‒ APS: 68.7% (8th), PL: 391-9 (10th), Survival: 54.88%
  • Fix KnnMeleeSurfer weight normalization now that every scan is weighted.

0.3b - 10.20.2017

• MeleeRumble ‒ APS: 68.7% (8th), PL: 394-6 (7th), Survival: 56.21%
  • Use weights instead of probability for possible targeted enemies when the enemy shoots. Probabilities normalize nicely, but my current logic didn't expect that. Maybe I'll rethink that in the future.

0.3 - 10.19.2017

• MeleeRumble ‒ APS: 68.7% (8th), PL: 393-7 (7th), Survival: 55.79%
  • Build a simple probability distribution for possible targeted enemies when the enemy shoots.
  • Build a simple probability distribution for possible targeted enemies when the bullet hits someone/another bullet.
  • Succesfully handle bullet-hit-bullet event.

0.2.3d - 10.17.2017

• MeleeRumble ‒ APS: 69.22% (7th), PL: 395-5 (5th), Survival: 58.32%
  • Lost track of important changes of 0.2 while running a backup before changing computers. Incorporate them back, 0.2.1 to 0.2.3c didn't have these changes.

0.2.3c - 10.17.2017

• MeleeRumble ‒ APS: 69.22% (7th), PL: 393-7 (7th), Survival: 58.88%
  • Fix signal.

0.2.3b - 10.17.2017

• skipped
  • Use some heuristic to estimate more precise MEA from current lateral velocity.

0.2.2 - 10.17.2017

• skipped
  • Use 110% of common bot width. Maybe it helps to take into account imprecision in wave position.

0.2.1 - 10.17.2017

• MeleeRumble ‒ APS: 68.91% (8th), PL: 393-6 (6th), Survival: 55.7%
  • Add 1v1 movement from Knight, so the impact of melee surfing only affects melee.

0.2 - 10.13.2017

• MeleeRumble ‒ APS: 68.84% (8th), PL: 391-8 (9th), Survival: 56.14%
  • Use a simpler interpolation for the enemies.
  • Use enemy interpolation everywhere (mainly in TargetingLog, which causes the biggest change).
  • Add error parameter to the fire events, such that the pair [time, time + error] indicates the ticks that this enemy could have fired assuming the heat tracker was correct.
  • Use EnemyLog interpolated position as firing position.
  • Improve fire-and-hit checking: before, hit + fire at the same tick would pass undetected. Now it works, but I'll apply other heuristics to catch K hits at the same tick (when gun is heated) with branch-and-bound.

0.1.1 - 10.12.2017

• MeleeRumble ‒ APS: 67.65% (10th), PL: 390-10 (10th), Survival: 56.71%
  • A bunch of tiny improvements to reduce memory allocation, garbage collection and math calls. A lot of "constant" optimization in the branch() function.
  • Using now a less accurate iterative predictor to generate paths.
  • Fixed a bug where I would merge the stats for each enemy without weighting them. This should make a huge difference.
  • It is still skipping a lot of turns, but way less than before. Branching in the future seems even more impossible.
  • Removed every gun except the PIF gun to start scaling my APS from that.

0.1b - 10.11.2017

• MeleeRumble ‒ APS: 50.71% (207th), PL: 205-195 (196th), Survival: 23.54%
  • Medina was not dealing well with skipped turns, and I didn't notice Medina was skipping turns because I was on an alternative computer with increased CPU constant.

0.1 - 10.11.2017

• skipped
  • First release.
  • Very simple fire-and-hit detection, a lot of room to improve.
  • Wave hit during danger evaluation is very stupid, waves are single-tick, often off-by-many-ticks and there is no accurate bot-wave intersection.
  • Quickly tested, brand new and hand-weighted minimum risk + true melee surfing, which is for now used in 1v1 as well.
  • It's not too optimized, it's a bit slow for now, and probably memory hungry. The only optimizations are stats caching and discarding irrelevant logs (like from an enemy which is too far from me for its data to change anything in my decisions).
  • Surfing views are really simple, accel + velocity + distance for now.
  • Minimum risk component is based on Monk's, but simpler: perpendicularity, distance and being one of the closest to an enemy are taken into account.
  • Initial movement is too simple, it's getting constantly cornered (unfortunately, during the game as well, but this is a harder issue).
  • Using traditional MEA everywhere. Maybe, since the movement in melee is really restricted, this can be improved.
  • Enemy logs interpolation only when detecting a hit (not when firing, causing a lot of off-by-many-ticks waves).
  • Bullet-hit-bullet events are not used.
  • Every time an enemy gets hit, it's inferred it surely was the target.
  • Every scan is inversed by enemy's distance because it's the most obvious way I can think to weight the chance of each enemy to be a target.
  • Guns from Monk.