Woo! Managed to get 93k+ while recording. Could have gone longer, too, if I hadn't made one mistake. Subscribe to the TouchArcade YouTube channel
Not sure if there's a cap on how high you can possibly score. I think I heard someone got around 250k, but is that a perfect game? Not sure.
At first I thought that would be impossible as I was struggling to get 10,000. The trick is to fouls on half the board at first and slowly expand as to get more splits. I just go 90,000 and could have gone higher but for a mistake. Once your up that high any wrong move quickly leads to defeat.
AppUnwrapper thanks for that video. I'm really digging this game now, thought the lack of GC would kill it but was wrong. This is better then your average puzzle game for sure.
Welcome! Have no life now. I really did not expect this game to take over like this. I keep saying "this next one will be it!" I must have played at least a thousand games by now.
Thanks for the video AppUnwrapper, this looks pretty cool, and the sound effects are pretty rad, might need to get this
I understand the game, but i am not sure i "get" it. Went through the video the Appunwrapper posted, and i cant say i can say why many of the moves worked, except later they did. Is there a method somewhat to why an area whould be made into a split block, vs some other area?
The better you get, the more steps you need to apply to your strategy. An area will become a split block when it contains a group of exactly same sized blocks of an even number, of at least 4 (2 per column, 2 per row) What worked for me was... First, I just tried to make as many cells as possible, as small as possible, in groups of 4 block splits. To do this you need to make sure that you don't accidentally trigger the cells before they are small enough. eg. Make sure the cells on each half are uneven shape. Second, you should try to put higher number cells on top of lower ones. So when the lower numbers on the bottom count down, the higher number will drop, and then be halved. Third.. There's more to it but you'll figure it out, I believe in you. Well now I see why nobody tries to explain this game, it doesn't translate into words easily at all. There is more to it then that. But it's sure fun to play. It's also very simple if you can believe that, which I didn't until I "got it", which didn't take long after watching the mentioned video.
Agh, I was trying to solve this game, but then I realized that gravity and filling makes it so you can't describe the state of the board using a binary tree formal language. That makes things so much harder... Maybe you could get an optimal game while staying in those restraints, but I doubt it, and I'm shutting off a lot of avenues of play if I do stuff like that. I really shouldn't be working on this right now, I'm going to drop my apparently useless method for describing the board here: h is a horizontal split, v is vertical, where there is a cross, h wins, and v is described on either side of the h. () is for left/up, [] is for right/down. The beginning of the line has the number of splits so far, the end has the score. So for example, the first few moves of a game: 00 1h1 2h(v)2 3h(v[h])3 4h(v[h])[v]4 5h(h(v)[v])[v]5 -> 5h(h(v(5)[5])[v(5)[5]])[v]9 The numbers represent point blocks. end state looks like: Code: splits: 5 score: 9 ----------------- | | | | 5 | 5 | | | | |---------------| | | | | 5 | 5 | | | | |---------------| | | | | | | | | | | | | | | | | | | | | | ----------------- Sometimes due to gravity a block can't be described as precisely split in half, so I can't actually use this like I hoped. I could maybe just adapt it to splits other than halves, though? I'll consider it, but I'm supposed to be working right now! Good luck if anyone else picks this up, it's much trickier than it seems.
150,935 with 521 splits is my best so far, but nailing down something even close to a solid technique is proving incredibly difficult. Definitely looking forward to someone figuring out what all the hidden messages are about.
Maybe it's easier to store the blocks based on the smallest block size. For example, if at the most subdivisions possible, the board fits 8 blocks across and 16 blocks up and down, you could set this up as a coordinate system ranging from (0,0) to (7,15). In python, I could represent the initial state with Code: [sum([[(x, y) for x in range(8)] for y in range(16)], [])] This looks like Code: [[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0), (0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1), (0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2), (7, 2), (0, 3), (1, 3), (2, 3), (3, 3), (4, 3), (5, 3), (6, 3), (7, 3), (0, 4), (1, 4), (2, 4), (3, 4), (4, 4), (5, 4), (6, 4), (7, 4), (0, 5), (1, 5), (2, 5), (3, 5), (4, 5), (5, 5), (6, 5), (7, 5), (0, 6), (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6), (7, 6), (0, 7), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7), (7, 7), (0, 8), (1, 8), (2, 8), (3, 8), (4, 8), (5, 8), (6, 8), (7, 8), (0, 9), (1, 9), (2, 9), (3, 9), (4, 9), (5, 9), (6, 9), (7, 9), (0, 10), (1, 10), (2, 10), (3, 10), (4, 10), (5, 10), (6, 10), (7, 10), (0, 11), (1, 11), (2, 11), (3, 11), (4, 11), (5, 11), (6, 11), (7, 11), (0, 12), (1, 12), (2, 12), (3, 12), (4, 12), (5, 12), (6, 12), (7, 12), (0, 13), (1, 13), (2, 13), (3, 13), (4, 13), (5, 13), (6, 13), (7, 13), (0, 14), (1, 14), (2, 14), (3, 14), (4, 14), (5, 14), (6, 14), (7, 14), (0, 15), (1, 15), (2, 15), (3, 15), (4, 15), (5, 15), (6, 15), (7, 15)]] The second state would be Code: [sum([[(x, y) for x in range(8)] for y in range(8)], []),sum([[(x, y) for x in range(8)] for y in range(8,16)], [])] Which evaluates to Code: [[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0), (0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1), (0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2), (7, 2), (0, 3), (1, 3), (2, 3), (3, 3), (4, 3), (5, 3), (6, 3), (7, 3), (0, 4), (1, 4), (2, 4), (3, 4), (4, 4), (5, 4), (6, 4), (7, 4), (0, 5), (1, 5), (2, 5), (3, 5), (4, 5), (5, 5), (6, 5), (7, 5), (0, 6), (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6), (7, 6), (0, 7), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7), (7, 7)], [(0, 8), (1, 8), (2, 8), (3, 8), (4, 8), (5, 8), (6, 8), (7, 8), (0, 9), (1, 9), (2, 9), (3, 9), (4, 9), (5, 9), (6, 9), (7, 9), (0, 10), (1, 10), (2, 10), (3, 10), (4, 10), (5, 10), (6, 10), (7, 10), (0, 11), (1, 11), (2, 11), (3, 11), (4, 11), (5, 11), (6, 11), (7, 11), (0, 12), (1, 12), (2, 12), (3, 12), (4, 12), (5, 12), (6, 12), (7, 12), (0, 13), (1, 13), (2, 13), (3, 13), (4, 13), (5, 13), (6, 13), (7, 13), (0, 14), (1, 14), (2, 14), (3, 14), (4, 14), (5, 14), (6, 14), (7, 14), (0, 15), (1, 15), (2, 15), (3, 15), (4, 15), (5, 15), (6, 15), (7, 15)]] It would also make sense to have a block class that stored a list of the points it covered, as well as its number if it was counting down.
Interesting... A new update, 66.6MB, a "minimalistic fix related to the Japanese version". That's a pretty big "minimalistic fix" for one language...
