Freeform Invisible Tetris (Phantom Mania Cleared)

Hello TC! I've spent an enormous amount of time and effort developing and perfecting a unique system that I believe unlocks freeform (i.e., no bag and no PF) invisible play. Here's some of the (best) things I've managed to do with it.

Now, "systematic freeform" Tetris is a bit of an oxymoron. The technique is not about where pieces go, but rather about memory. At least for me, visualisation is just no good for anything besides the contour of the stack, so I instead went with brute force memorisation via method-of-loci. With this system I can quickly reconstruct any part of the stack. I do hope to use this method to clear Phantom Mania "legitimately" (i.e. TGM Randomiser + SRS + Step Reset), but for now I hope this demonstration suffices. Of course my average performance is not this good, but I rather wanted to show that the realm of possibility is quite large, given a concerted effort.

EDIT 17 Oct 2015: Cleared the game and credit roll! Orange-Line MM:

And an M-roll with bone blocks, recorded live:

Cheerio,
-QM

 

blueapple128 from Youtube here.

Tip: Looking at it, the thread title doesn't quite convey the awesomeness of the video, which might be why this isn't getting too many views. Maybe rename it to list out some of the accomplishments?

 

That's a good suggestion. I figured I'd say what it does on the tin and reduce spoilers, but c'mon, people!

 

This is really cool Mark!

It sounds like your approach is quite a bit different than the typical approach used by TGM players. I'd love to learn more about it. Have you written up a guide or a FAQ or anything?

 

Thank you very much.

As you might have guessed, I have documented this in great detail.

The first part is something I call afterimages (I don't know if it's visualisation or memorisation because I don't even know why it works...). If you look at something on your screen (say, this post) and quickly shut your eyes, you can still "see" a lingering image... for about a quarter second at best. I play Tetris with a solid black background and no gridlines, so the lock flash takes the place of rapid blinking. At first I just used afterimages to visualise the contour of the stack, taking advantage of the quarter-second mental image. The problem I found was that my surface memo was fast and efficient, but I could never remember any holes.

Enter part two, the method of loci. Even an average person can close their eyes and pretty accurately recall lots of details about their bedroom. This is an embryonic memory palace, a place to which you affix new objects so they stick in memory. To make a location a memory palace, you need to commit such a location firmly to long-term memory, identifying points of interest in the location (loci). While memorising, you either tie the thing-to-be-memorised to the locus, or encode it first if the thing is abstract, like Tetris.

Memory palaces can be anything from the aforementioned bedroom to a house, an office, or maybe a drive to an office. Besides how well you remember it, the relevant aspect is the number of loci, i.e. how many points to connect to; a relatively clean bedroom might have between 5 and 15 loci. Nothing I was deeply familiar with had enough loci, so I built an artificial memory palace - they don't actually need to physically exist, as long as you can picture them perfectly.

My method uses a system of 260 loci; the main 200 hold the "raw" state of the 10x20 playfield; if a square from a Tetromino occupies the square, I put something there. Another 30 are sort of my RAM - 20 for rows, 10 for columns - and the combination of objects I put there tells me what that row looks like. This is redundant, but has merits that the raw 200-bit storage lacks. The 20 row loci let me determine how many holes I need to fill in a given row before it's cleared. I use the 10 column loci - as you might notice in the video now - 1) if a given hole is more than 1-deep and needs {I,J,L} to clear, and 2) for determining if there are other holes I can join up and drop a multiple line clear. Column and row loci, together with afterimages, work mind-blowingly well for setting up twists. At an overhang, two adjacent row and column loci are misaligned by one square. The last 30 effectively help with "compression." All of this memory stuff is kinda overkill when my stack is clean. If possible, I store individual empty 1x1 gaps in my stack here by encoding their row with a letter A-T and column with a number 0-9 (single digits helps ). When I have no holes in my stack, these loci are empty; I also can totally disregard all but the top-most squares in the 200-bit storage, and most of my row info - thus compressing the memory load to a contour and some relative and absolute height information on the stack as a whole. A 1x2 gap gets encoded and written to two loci, a T-shape gets four, and currently if I exceed 30 squares' worth of holes I stop writing to those 30 loci - I also die shortly thereafter.

Anyways, the upshot of this is I'm able to memorise the entirety of the stack - twice over, and usually holes are memorised thrice over. That's mostly an insurance plan, as double-checking improves my accuracy. If there's a discrepancy I go with the raw memory over row/column gridding because the former is seldom wrong. If there are no discrepancies while writing to memory, I just read row/column information because it's easier and thus faster.

Whenever I place a piece, I update those position loci (of 200) that change as a result. Every line clear adds 1 row and up to 9 (collinear) positions to update, so a non-clear updates at most 4 position loci, singles 13, doubles 22, triples 31, and Tetrises 40. Since my position loci can be divided into tens by row, those extra updates aren't as difficult as they sound. In fact, Tetrises are the easiest by far. After updating the positions, I also modify the contents of the relevant row and column loci (thankfully, no more than 4 of each regardless of line clears), and, if the 200-bit system indicates I have a hole, I write all empty squares to the next available compression loci assuming not all 30 are used up.

Now, writing so much stuff to so many loci so often is the polar opposite of trivial. When first testing this mnemonic system, I could play Practice mode with invisible settings and unlimited lock delay, with all the speed and swiftness of continental drift. But now it's such a routine, well-practiced thing that I can update my memory with every new piece in - you guessed it - a quarter-second. Which means I can establish an accurate position for each newly placed piece before its afterimage fades from memory.
--------------------------------------------------------------------
Okay, there's no way that was easy to swallow, but I'm certain it's comprehensive if not comprehensible. This system has two counter-intuitive side effects that I personally find hilarious:
1) Since it relies on memorising the piece while the afterimage is still visible, in that extreme short-term memory span, I physically cannot play slowly, and...
2) The top of the stack is memorised first with afterimages, then visualisation, and finally rigourously committed to a memory palace - by which time it's no longer the top of the stack. I very consistently know the deep field of my stack more accurately than I ever know my contour. It's like some kind of backwards fading roll.

I hope this offers some insight into my approach to invisible gameplay. It may not work for you, but I assure you it works very nicely for me. My biggest problem moving forward is not invisibility, but just controlling pieces moving at Death 500. "Even" with SRS, it's a legitimate obstacle because I disabled the move/rotate resets in Standard-Hard. In terms of survival past 500, the recent 745 MO was probably 2 standard deviations above my norm. I've taken the advice of many to not bother with pyramid stacking, but keep the middle columns higher when possible, and it seems to help loads after Phantom 500.

With complete memory of the Tetris stack and lots of Tetris clears, I think straight-up survival to 999 is basically all I need to get GM. Not that Death 500 is easy, but compared with this monumental bloody effort, I think you'd agree it's relatively straightforward to learn.

 

Thanks so much for the comprehensive AND comprehensible essay on your method, lol. You are truly one of a kind QM - I hope others will appreciate how special your skills are .

Can't wait to see GM!

 

That's a great write up thanks a lot! I actually just started reading Moonwalking with Einstein so it's pretty timely and totally made sense.

Believe or not my reaction is still "tell me more" haha

Can you describe more precisely how your memory palace is set up and/or point me in the direction of further reading that would put me in the position of being able to design my own memory palace? I'm just excited because it sounds way more palatable to me than the typical brute force black magic approach.

 

Awesome! I find that hard to believe, but if you're up for it, sit tight, make yourself a cuppa, and grab some popcorn because this is the unabridged version.

If you want to design your own memory palace, a good starting point is the Wikipedia article on the method:

http://en.wikipedia.org/wiki/Method_of_loci

I recommend this as a starting point mainly because it was mine. You might get ideas just by reading through some implementations, history, etc. I would've actually recommended Moonwalking with Einstein, so you'll be in a great position after (and while) reading it. A fantastic example of things you can populate a memory palace with is Maskow's memory system (Marcin Maskow is something of a god among Rubik's cube blindsolvers).

Really, though, I basically Googled "memory palace" and "method of loci" and read whatever looked interesting, and once I felt like I knew what I was doing I started designing mine. You don't actually need a lot of overhead to build a memory palace - the memory palace is the investment itself.

From your wording it sounds like you want an artificial one - the best way to start is to decide what you want it to look like. Not even the sky's the limit - my memory palace is a space station of sorts. If you want lots of interconnected things, don't be afraid to make it a literal palace - with a castle and lots of bridges. It might help to have a wide-open sandbox game like Terraria or Minecraft, so you can literally build it to your own specifications. Incidentally, when building/designing I've found this kind of decision to be particularly helpful: If you're torn between a structure/design you built first, and an alternative you built later, and can't pick, always go with the first one; it sticks in memory better than the improvement ever will. And if that makes it look kind of out-of-place, perfect - that makes it easier to remember. I'll try to offer advice where I can but mostly I'll just be describing my system in as much detail as I can make interesting.

If you want to use exactly this method (substituting your own memory palace), you're going to need 230-260+ loci (depending on how many holes you want to be able to downstack, and how much you can remember). I've setup the first 200 as 20 rooms of 11 loci - somewhat modest hotel rooms (yes, out of place for a space station - see above tip). I've split them into four floors so the ground floor is the bottom quarter of my playfield and the 3rd floor is the top quarter of my playfield (so if anything happens in these rooms, I know it's an emergency). I always move from one room to the next in a specific order, so that my memory sweeps out my "local" playing field, the region where blocks are being added. The first 10 loci are things like lightbulbs, tables, nightstands, refrigerators, beds, etc.; the 11th is the rubbish bin, which is my row locus. Now, those 10 loci just tell me if their corresponding squares are filled, so I basically just need to "toggle" them; I switch the lights on/off, put a mug on the table, make the bed, etc. For the bin, contents matter. My Tetris well is on the left (because I'm weird), so I use this rubbish encoding system: Starting from the right-most column, count how many columns of solid squares there are before I hit the first hole. This number can be anything from 0 to 9; if 0 (i.e. there are at least 2 adjacent empty cells), I put a magic 8-ball in and continue. Two 8-balls means a 3-wide hole, etc. The left-most hole ignores the 8-ball rule - in particular, an empty row is the left-most hole and leaves the bin empty. Since everything's in space, I can just place things vertically and they hover in place, so I can read the bin from bottom-to-top. Most importantly, if I have a perfect Tetris well for that row (9 right-most squares in), the bin is filled with blood. You don't have to get so morbid, but trust me - gross things are easier to remember.

The rest of my system is a mess hall/cafeteria (below the ground floor) where I store column loci in 10 tables and have a copy of the 20 rubbish bin row loci (I often use row and column loci together to "grid out" my playfield). The tables store column info in much the same way - start from the bottom. How many squares till I hit the first hole? (0-20) Repeat until I've reached the top most square. In practice I don't need more than 10 people per locus, but if necessary I can add more standing and milling around the table. Each person has a tray of food which encodes the number 0-20. Of course, 0 is indicated by the person "not feeling hungry," and having no tray. Most are just familiar meals to me, but 16-19 have copious amounts of food laced through with blood, and 20 is a plate of rhubarb on fire. (I very rarely see these; you pretty much only get them by stacking cleanly too high). This imagery not only sticks out, but is grotesque enough for me to want to avoid seeing them, preventing me from, well, stacking cleanly too high.

This might seem overly complicated. However, I can't stress enough the advantage it gives over directly tagging each cell in a row/column as filled or empty. Doing that would necessitate 10 and 20 objects at each locus that I could add or remove, or alternatively encoding (in binary) the row as one of 1,024 (2^10) things, a column as two of them. That is either lots of objects present, or lots of thinking to decode a single object out of so many. Furthermore, the more cleanly I stack, the more complicated things get - 9 cells/row and pretty high columns means lots of filled-in cells. This method has a built-in compression. If, say, I stack without holes, then all the perfect rows are just rubbish bins full of blood (and nothing else), and all the columns are tables where one lonely bloke is eating a roast beef sandwich or sausage or a plate of rhubarb on fire. Conversely, when my stack starts to fall apart, there are lots of people eating lots of food, the bins are full of junk and, apropos, everything is generally thrown into panic. Now, to entertain these alternatives... you could have rows/columns as, say, army soldiers, students, a collection of valuables, or otherwise something we expect to keep account of. Holes would be a person gone missing/a ring having been stolen, and thus spark concern, whereas a clean stack means everyone is accounted for. If that floats your boat, by all means, roll with it - I've not found much success in it for myself.

Finally, the compression loci are fairly optional, but you can have as many as you want. Currently this part of my system is most expandable - I can imagine expanding to as many as 70 compression loci, but I think 30 is already overkill (unless I really botch things up). If you want to downstack holes, I'd recommend 10, or 5 at the bare minimum. Right now we've accounted for 230 loci, and my 30 compression loci bring the total to 260. I have all of them stored on the "bridge" at the top floor of the questionable space station/hotel/eatery thing. Various control panels have buttons, switches, and alarms (Apollo-style), but I don't know what any of the displays say ahead of time. When I have a hole in my stack, the first button lights up and displays a letter A-T paired with a number 0-9 (say, G8 or L3), corresponding to the location of that hole. Multiple adjacent holes (like a 1x2, 2x2, T-shape, etc) light up not only buttons but also alarms, so that I know I have a compound hole. Every compound hole sounds a different alarm - when I have a mental cacophony I know I'm about to die.

Once you have the system in place, it's just a matter of practice. Phantom Mania or M-rolls are terrible places to start practicing; instead, I went with Practice mode, invisible, 20G settings, and unlimited lock delay. At first it may take 20 seconds to establish a piece in memory - that time gets shorter and shorter with repetition and practice. Just about the hardest thing about this approach is the amount of simultaneous operations you need to do - besides writing to position, row, and column loci for every piece placed, you also need to write holes into compression loci when they form (intentionally or unintentionally!), and when line clears change the nature of holes, some compression loci also change. It... really doesn't get any easier, but you get better at it. Remember: With memory, practice makes permanent. And permanent is good.
----------------------------------------------------------------------------------
That should be just about all the relevant details - if you want to clone this exact memory palace into your mind and start populating it, please feel free. I've not gone into much detail about what rubbish or meals (or rubbish meals) correspond to which numbers, but that seems like a personal preference and I'd recommend you encode them however you find most memorable. Maybe you want a completely different memory palace; just know that this method uses 200 position loci, 20 row/10 column loci, and as many compression loci as you can be bothered with. You can have either raw positions or row/column gridding or both. Just one is enough to reconstruct the entire stack, but having both lets you check yourself before you wreck yourself. If you must go with only one, here's your cost-benefit analysis: 200-bit storage is lots more loci, and slower at first, but much more consistently accurate; row/column gridding is much less loci, and faster, but easier to mess up.

Happy invisibling,
-QM

 

Not sure why there are so few replies but rest assured your posts have been awesome and I've read every word twice. Seems I have a lot of work ahead of me!

Though I probably will use an artificial memory palace, what I meant about designing my own is applying it to other purposes. Like, it might be cool to explicitly remember the randomizer state. A promising application is in another puzzle game I love, Star Sweep. I noticed the game gives you a random 30 pieces, and then loops those 30 for the rest of the game. If you explicitly remembered the sequence you could score ridiculously aggressively, it'd be a whole new level. I'll probably start with something smaller like that and see if I've got what it takes before committing to something crazy with 200+ loci.

Incidental, do you think memory palaces are reusable for different applications or do you have to keep making new ones?

 

Go for it; It's not so bad if you break it up into daily, manageable chunks such as one room per day or even a couple of loci per day. And there's nothing wrong with backtracking - maybe filling in more details when you think they'll make it more memorable (I took the whole rhubarb on fire idea from the Portal cake core well after I'd set up the cafeteria system). I'm firmly convinced anybody who so desires can establish and use a memory palace successfully.

Oh yes, no doubt about it, remembering randomiser states is awesome. Come to think of it, you could do the exact same thing to track cards dealt from a fixed random deck or series of decks (which may be of questionable legality - play at your own risk). I haven't really found many games where the future randomiser state depends explicitly on previous data you can visually extract from the game, but your discovery of Star Sweep's randomiser behaviour screams "memory palace" to me; if you're fast enough you could dominate with that kind of method. For that you need nothing anywhere near as crazy - you could do it with a 10-locus system, tying elements of the random sequence to loci in threes. Such a system could be grounded in reality, say a bedroom or office, but with a little work an artificial memory palace of similar scale could do still better.

For randomisers and sequences, it's really important to work out a journey through your memory palace, i.e. a path you consistently take to write to and read from your loci. You'd go through the first time writing the sequence in, and forthwith you keep going around in exactly the same path reading the various elements. I do that to a lesser extent to sweep out the active rows of my Tetris stack. Ideally, you want to establish this fixed path before you start using your system for reals - then when you recall the sequence, it's an absolute walk in the park. (Literally, if your memory palace is a park.)

I'll throw an idea out there - if your memory palace isn't to be used directly for Tetris, you could try making it a Tetris well and the different random elements Tetrominos. It's possible that your experience with Tetris will make such a system easier to remember. May work for you, may not, but it's worth considering if you're going the artificial route.

I'm positive that they are. I've put my Tetris one to good use in Rubik's cube multiblind (memorising multiple cubes and attempting to solve all of them blindfolded consecutively). I can do two consistently and, theoretically, could solve 11-12 with this system. It's not hard to recycle a memory palace, but if you go to the trouble of engineering it perfectly for one thing, using it for another does feel weird. That's the main reason why I have several for different memory tasks (and I believe some memory champions have dozens). But yes - if you built a memory palace to remember the first 30 random pieces that loop throughout Star Sweep, you could later reuse it for something like the M-roll or maybe blindsolving. In fact, if you want to reuse it and find that you've not enough loci, you could build an "M-roll wing" to extend your old memory palace so that 1) you have enough to work with, and 2) you didn't need to start over from scratch. I did exactly that when I added row/column loci via bins to every room and a cafeteria, and then the compression loci afterwards. It's like "pimp my memory palace."

EDIT: This is kind of off-topic, but I just realised something funny. Since the bins are my row loci and I track holes in my stack laterally with them, I technically store garbage lines in my rubbish bins.

 

Don't worry about the lack of answers, I think everyone is baffled that this thing even exists in the first place. I'm literally reading this and having so much trouble believing it. This opens up everything! I can't imagine how easy it could be to play the M-roll now if this method is used.

I'll finish with appropriate video of me trying to have this down.

Thanks for your insight, I'll try to master this as much as possible.

 

This thread is awesome.. and really tell me i should spend more time checking this forum again than FB bullshit
anyway i don't understand very much how it work but i'll read more about this loci thing..
i'm very interested about mastering this kind of technics

 

Hi,
I finished "Moonwalking with Einstein". This book is a "must read" for everybody ! This is a very good introduction to the Memory of Loci.. Some point of interest for everybody here : What it take to become good at something, the OK plateau concept and.... a GrandMaster achievement.
For french people, i encourage you read the english version because the French translation is IMO not very good ("aventure au coeur de la mémoire")
i'll definitly go into this ! QM : can you point some community link about this subject ?!?

 

Actually beginning to read the French version. I think we're having a bunch of people there who want to make the m roll a formality

We ain't needing any matrix

 

Bump for a very important update: I've cleared the game under the TGM randomiser - in 4:59.13.

All GM requirements met (including 31 Tetrises total) until 800-899, so the grade ended up being orange-line MasterM. So close! Knowing I wouldn't make GM this game, I would've been satisfied with green or orange MM either way.

Also...

I don't blame you - my claims are extravagant to say the very least. But scroll down just a bit and you won't have to believe.

Your phrasing made it too tempting. I set up the M-roll as best I could using NullpoMino's Practice Mode (Death 500 for 54 seconds). Here's me "trying my hand" at the M-roll - with my own special twist I'm sure you've noticed.

(I think I calculated my points correctly, but someone let me know if I did it wrong.) Essentially the limit of my speed capabilities with a one-handed control scheme. The game was quite lucky with the randomiser, very clean, and had two perfect clears back-to-back - one with a Tetris, the other a mega-rare 5-piece PC. Plus more than 60 lines cleared, and I finish at the bottom of the Matrix. Couldn't ask for a more perfect credit roll.

The fact that grandmother blocks are grey brackets does make Next queue recognition much harder, but there's a bigger challenge for me specifically - no lock flash means it's hard for me to induce an afterimage to memorise the pieces. I make do with placing extremely quickly to trick my brain into thinking it's a lock flash, and otherwise just blinking to force the afterimage. Normally, bone-blocks also turn off line clear animations, but I tweaked Practice Mode settings to enable them regardless - it's much more spectacular to watch the Tetrises fall.

Good luck to you, K!

Honestly, I wish I had more to say about it (not enough mega posts! ><). The fact is I came across the method of loci from Wikipedia, learned more from "Moonwalking with Einstein" + random Googling, and developed this system from scratch. Really anybody can do it - just start small, like with your bedroom. If you want to test out your memory palace, try solving a Rubik's cube blindfolded; it's a more prevalent mind sport than most people think, and also easier than it sounds. If you use the Classic Pochmann method, you really only need to memorise between 19 and 22 things, which is quite doable with a bedroom-based memory palace.

I was kind of thinking: My main exposition posts above describe 1) the general way I play invisible Tetris and 2) the detailed workings of my mnemonic system. I haven't really gone into the specifics or examples of how my memory palace assists in some aspects of Tetris gameplay (e.g. lining up holes, overhangs, forecasting T-spins, etc). As you may have noticed I make perfect clears quite often in these games; I suspect the detailed knowledge of my field state assists majorly with that. I dunno if you want to hear me discuss that, but it might be more useful and interesting than what I've already written up.

That's all I've got for now! Hope to hear from you all soon.

Cheers,
QM

 

Once again, I can't express enough gratitude and excitement for the things you've shared and demonstrated for the Tetris community. I'm excited to see how far you can push the boundaries even more!

 

Love the GIF, K!

 

Hi, QM !

I have several questions about your method that i don't understand
You explain your system use around 260 loci. As you mentioned it's a lot of overkill information to process !! seeing how you master the exercise you surely handle without problem 2 pices a seconds ! since you are able to memorise the entirety of the stack - twice over, and usually holes are memorised thrice over, how many Writing/erasing are you doing each seconds to your memory palace ?!

You are using at least 200 of your loci like a bit information storage in 20 rooms of 11 loci by toggling :
Now, those 10 loci just tell me if their corresponding squares are filled, so I basically just need to "toggle" them; I switch the lights on/off, put a mug on the table, make the bed, etc
can you you be more specific about the description of your "toggle action" ? i want to strongly inspire myself to your system
Does your hotels rooms all looks the same ?

When you erase line, how you do handle down-stacking and information changes into your palace ?!?
How are you reconstructing the playfield image ?

Cheers

 

I also appreciate the GIF.

The numbers that matter are about 6 to 12.

It depends on my play speed. In Phantom Mania 0-99 I can't really do more than 2 TPS which is 6 operations per second. In the monochrome M-roll video I was pulling 4 TPS at times, or 12 operations per second. I have to update more loci than that but I do them all together as one "calculation." For example, I don't have to update 4 arbitrary loci every time - there are only 19 different possible orientations among all pieces, so I only need to update one of 19 combinations of 4 adjacent loci. I combine all row/column loci per piece into one update each, so every piece needs only 3 operations instead of 8-9. (I believe this strategy is known as "chunking" in mnemonist jargon.) Line clears add only a small amount of operations which I'll explain later.

To be honest, it's really not a big deal anymore - encoding information into my memory palace is so second-nature now that I almost don't think about it. (Doing ~10 things a second is much easier if you're extremely familiar with it.) Most of the work I do is just actually keeping everything in memory, which is still tricky.

That's in terms of how much I have to think about my stack. Sometimes I group the updates for multiple pieces together if I think it'll be easier. However, the number of loci I update per second is much higher (and more misleading). In normal play and counting line clears it can get as high as ~30-35 locus updates per second.

It gets utterly ludicrous when I have Tetris combos In the orange MM video at level 320 I get three Tetrises in a row (randomiser, not doing your job...), momentarily hitting 12 lines/second. Each line updates 9 cell loci and 1 row locus, so 120+ locus updates/second. That will sound much less impressive if you read down further - the numbers grossly exaggerate how much information my brain processes.

Yes - against my better judgment, I made all of the rooms identical apart from toggled loci, rather than making them all very different. They live in different locations relative to each other (4 floors, 5 rooms per floor in a U-shaped layout), but when they're all empty they look exactly the same. For pure memorisation techniques, this is a very bad idea - but it has a huge benefit for use in Tetris.

From left to right, the columns are numbered 0 through 9 (normally 1-10, but I do 0-9 for my hole loci). For brevity I'll write "1" when the corresponding square is filled, or "0" if it is empty.

Column 0: The door; open=0, closed=1. (I generally want this one open for Tetrises.)
Column 1: The lights; off=0, on=1. (I generally want this one filled.)
Column 2: The end table; 0 if there's nothing on top, 1 if something is there - e.g. a book, teacup, camera, whatever.
Column 3: The bed; clean=0, messy=1.
Column 4: The contents of the toilet - use your imagination. (This is pretty awful, but let's face it: It's important to know if this column is higher than the others, so I need something that stands out in memory. Most players call this "Column 5.")
Column 5: The television; off=0, on=1.
Column 6: The radiator; off=0, on/possibly setting things on fire=1.
Column 7: The Rubik's cube on the desk in 9. Solved=0, scrambled=1.
Column 8: The telephone; 0 if on its hook and 1 otherwise.
Column 9: The desk; tidy=0, papers everywhere=1.

As I mentioned before, I deliberately made all rooms identical. Here's why.

The simplest line clears for me are ones that leave no residues after clearing lines. Among these, the most familiar is a Tetris:

Notice that I have to transfer the information stored in Row 5 down to Row 1, Row 6 to Row 2, and so on. This is the huge advantage of identical rooms - I don't have to manually update 36 loci every single time I clear a Tetris. I just mentally switch out the two rooms in an instant, and I'm good to go. Instead of the hardest line clear it becomes the easiest line clear. I don't even have to update piece information, since the whole I-piece gets used up.


With pieces that leave residual blocks after clearing, it's a little more complicated. Once I place the piece, I update the loci for the squares that don't clear. The rest doesn't matter because I erase the whole row from memory anyways, so no point in updating it.

Hurdles are the most complicated situation partly because different rows move down different distances, and also the non-clearing squares are harder to spot - although there are necessarily fewer of them.



I don't have time to Fumen a full 15-row downstack right now, but every single line clear operates on exactly the same principles. I update whatever squares didn't clear blocks, reset the 11 loci in each cleared row, and shift all loci down. Erasing an entire room is extremely easy, and I don't have to update as many squares per piece (1-4 squares are lost to the row I cleared), so my "writing" operations are actually simpler in downstacking. This is important because my "reading" operations are much harder - I still can't downstack quickly. By contrast, I "read" much less when stacking up and/or playing cleanly.