StarCraft | decentralised micromanagement scenario of StarCraft II | Machine Learning library

Starting Status S is the initial state at the start of the game. I believe you have 100 minearls and Command center and 12? SCVs, so that's your start.

The Goal here is the list of building you want to have. The satisfies condition is are all building in goal also in S.

The time limit is the amount of time you are willing to spend to get the result. If yous set it to 5 seconds it will probably give you a sub-optimal solution, but it will do it in 5 seconds. If the algorithm finishes the search it will return earlier. If you don't care leave it out, but make sure you write solutions to a file in case something happens.

Bound b is the in-game time limit for building everything. You initially set it to infinite or some obvious value (like 10 minutes?). When you find a solution the b gets updated so every new solution you find MUST be faster (in-game) than the previous one.

A few notes. Make sure that the possible action (children in step 9) includes doing nothing (wait for more resources) and building an SCV.

Another thing that might be missing is a correct modelling of SCV movement speed. The units need to move to a place to build something and it also takes time for them to get back to mining.

A pygame.Rect is created from the top left position and the width and height. The width and height must be positive. You need to find the minimum and maximum x and y coordinates of the 2 points. Write a function that creates the pygame.Rect object from the two points:

It looks like tensorflow.js does not have a bitwise AND function, so suspect doing the work within tensorflow.js will require some coding gymnastics...

One suggestion, though, is to create an array of 256 Uint8Array's of size 8, and pre-populate it with the complete list of 8 byte translations. This greatly reduces the repeated calculations for a byte stream that will likely have repeated values in the range of 0 - 255. Eg, the first entry in the precomputed array represents the unpacking of byte 0, and therefore is a Uint8Array of size 8 populated with 0's, the next entry is another Uint8Array of size 8 populated with 00000001, etc all the way to the entry representing byte 255 with is a Uint8Array of size 8 populated with all 1's.

Then, when unpacking, simply make use of the typed array .set method to copy the precomputed unpacked representation into the results Uint8Array...

Hope this helps.

EDIT Created a number of variants of the unpacking algorithm to test the performance of inline calculations vs memory lookup and was surprised at the results using Chrome. Some of the optimizations of the V8 compiler are non-intuitive...

The differences in the versions...

• unpackbits [FAST]: From the original question and this is the bar by which the others variations are compared.
• unpackbits1 [FAST]: Modified by...
  • Specifying "|0" after every integer.
  • Using the increment unary op ( "++" ) rather adding increments to the offset index of the result array.
  • Replacing the calculation of bit masks with the actual value. (Ie, rather than 1 << 5, the function used 32.)
• unpackbits1a [FAST]: The same as unpackbits1, except...
  • Kept the calculation of bit masks rather than integer values. (Ie, using 1 << 5 rather than 32, as in the original question.) Counter intuitively, this produces a bit faster result!
• unpackbits1b [SLOWER]: The same as unpackbits1a, except...
  • The offset is not recomputed every time inside the loop. Ie, offset = 0|0 is initially set, and then thereafter offset is only incremented within the loop. So, offset = ( (8|0) * i ) is no longer calculated for every byte. Counter intuitively, this produces a slower result!
• unpackbits2 [SLOWEST]: This is the memory lookup option that I recommended above. Counter intuitively, this implies that typed array memory operations are much slower than calculating the results as in unpackbits!
• unpackbits3 [SLOWER]: This is the memory lookup option that I recommended above, with the following change.
  • Rather than used the the typed array .set method, this version set the eight bytes one-by-one. Counter intuitively, this implies that the typed array .set method is slower (at least for eight bytes) than individually setting the values!
• unpackbits4 [SLOWER]: This variation of the algorithm was on par with the original, and was a variation of the memory lookup option. But, rather than 256 individual Uint8Array's, this combined all the pre-calculated results into a single Uint8Array of length 256 * 8. And it did not make use of the typed array .set method.
• unpackbits5 [SLOWER]: Same as unpackbits4, except...
  • Rather than using the unary "++" on the index into the lookup table, it calculated the index for each of the 8 bytes being copied. As expected, calculating the index every time was slower than using the unary "++" operator.

Here are the tests. BEWARE that this builds an initial array of 10M random bytes, and then runs each unpack algorithm on this same data. On my workstation, the test runs in less than 5 seconds.

You send the data to the template as races, not company.

I had the same error, the game's current version is not compactible with the modul. There is a thread about it: https://github.com/Dentosal/python-sc2/issues/283 There is also an instruction how to remove the error, it worked for me, so hope it will help you as well.

Below is for BigQuery Standard SQL

I have ran into the same problem as yourself. I commented out the following line:

assert self.bits_per_pixel % 8 == 0, "Unsupported pixel density"

within the pixel_map.py.

The map now loads correctly.

I guess it just needs to subdivide the problem and memoize the results. Example: 2 units. Unit1 goes from A to C but the shortest path goes through B. Unit2 goes from B to C. B to C only needs to be calculated once and can be reused by both. See https://en.m.wikipedia.org/wiki/Dynamic_programming

In this wikipedia page it specifically mentions dijkstra's algorithm for path finding that works by subdividing the problem and store results to be reused.

There is also a pretty good looking alternative here http://www.gamasutra.com/blogs/TylerGlaiel/20121007/178966/Some_experiments_in_pathfinding__AI.php where it takes into account dynamic stuff like obstacles and still performs very well (video demo: https://www.youtube.com/watch?v=z4W1zSOLr_g).

Another interesting technique, does a completely different approach: Calculate the shortest path from the goal position to every point on the map: see the full explanation here: https://www.youtube.com/watch?v=Bspb9g9nTto - although this one is inefficient for large maps

This might be obvious for some, but it took me 25 minutes, so I'll put it here.

The SC2 websocket is up once you completely installed and started the game.

Not only the battlenet interface.