All my secrets for winning MegaMinerAI 11 and 12. Despite giving away these secrets, I won MegaMinerAI 13 as well. Does that make this presentation a failure?

1. Winning MegaMinerAI
Writing Fast Code Fast
Bob Buehler

2. Overview
This is a messy presentation
Sorry
Ask questions?

4. Strategy
Our APIPathing
Base API
Solving
AI.cs
Solver.cs
Digger.cs
Pather.cs
Bb.cs
Pump.cs
Point.cs

5. x
y
x
y
x
y
x
y
x
y
Path finding interface
Keep it simple, right?
Start End
Path
Game
TilesUnits

6. Two sides to an interface

7. Breadth first search
open_queue = new queue(start)
closed_set = new set()
previous_map = new map()
while open_queue is not empty
current = open_queue.dequeue()
closed_set.add(current)
if current == end
return construct_path(end, previous_map)
else
for each n in neighbors_of(current)
if n not in closed_set
open_queue.enqueue(n)
previous_map.add(n, current)

8. Path finding algorithm
x
y
x
y
x
y
x
y
x
y
Start End
Path
NeighborGenerator
width height
Is_passable

9. BFS  Dijkstra’s  A*
Dijkstra’s is like breadth-first search except
• It can handle costs applied to steps
• get_cost(current, n)
A* is like Dijkstra’s except
• It can make better guesses about which way to
look first
• It does so by using a remaining-cost-heuristic
• calculate_h(n)

10. x
y
x
y
c
x
y
c
x
y
x
y
x
y
x
y
x
y
x
y
Flexible A*
x
y
x
y
x
y
Starts Ends
Path
maxYmaxX
x
y
x
y
x
y
Passables
costs
NeighborGenerator
heuristics
x
y
c
x
y

11. C# A*

12. What’s a Point?
x
y

13. What’s an IEnumerable?
System.Collections.Generic
• IEnumerable<T>
• GetEnumerator()
• IEnumerator<T>
• MoveNext()
• Current
• foreach (T x in e) { }
• Array<T>
• List<T>
• LinkedList<T>

14. What’s a BitArray?
new BitArray(width * height)
int index = y * width + x;

15. What the Func?
Func<T1, T2, TResult> myFunc;
Func<int, int, int> addEm = (x, y) => { return x + y; };
Func<int, int> squareIt = x => { return x * x; };
Func<int, int> squareIt = x => x * x;

16. C# A*

17. Uses of A*
To calculate a walking path

18. Uses of A*
To calculate where to spawn

19. Uses of A*
To calculate if a pump is pumping

20. Uses of A*
To calculate what trenches to dig

21. Uses of A*
To calculate what trenches to dig

22. Uses of A*
To calculate what trenches to dig

23. C# A* MegaMinerAI 11

24. Why rewrite?
• When do you rewrite code?
• When it’s not correct
• When it’s not fast enough
• When it’s not giving the information you need
• When it’s not accepting the information you have
• When it’s not easy to use
• When it’s not easy to understand
• When it’s broken because of another rewrite

25. Strategy
Our APIPathing
Base API
Solving
AI.cs
Solver.cs
Digger.cs
Pather.cs
Organize by dependency
Bb.cs
Pump.cs
Point.cs

26. What can C# do for you?
Good abstractions and base library
• IEnumerable<>
• Func<>
• BitArray

27. What can C# do for you?
Good abbreviations
• Lambda functions
• Type inference

28. What can C# do for you?
Extension methods

29. What can C# do for you?
Extension methods

30. What can C# do for you?
Extension methods

31. Conclusions
Write a flexible A*
• Multiple start points
• Multiple end points
• Configurable passability
• Configurable costs

32. Conclusions
Write code that doesn’t need rewriting
• Write tiny functions
• More correct
• More performant
• Write an input interface that doesn’t ask for extras
• More usable
• More understandable
• Provide output that is exactly what you’re willing to
support

33. Conclusions
Consider C#
• A very handy IDE
• More than fast enough
• The base libraries are solid

34. https://github.com/BobBuehler/megaminerai12