I didn't think he realized that the NES most likely couldn't layer sprites in a single draw call since he didn't seem to realize that both black could be any other color in the palette and transparency could even be an opaque color.
Transparency for sprites could never be opaque.
This is exactly how it works:
3 colors+transparent in a sprite palette. Because transparent is one of the colors, you can draw sprites on top of each other. Note that 0x00 is both black and transparent in that image. The number in the transparent slot can be any color in the palette, but it will still be "drawn" transparent for sprites. (The transparent color controls the "background" color, so one way to look at it is that background palettes are also only 3 colors + transparent. The background color fills the screen. The background tiles of 3 colors+transparent are drawn on top of it if they're set to be. The sprites of 3 colors+transparent are then drawn on top of that if they're set to be.)
I'm not sure what draw call means. The NES does the same logic for all sprites every frame they're enabled. If there are more than 8 in a scanline, the extras straight up don't get drawn. It depends more on what the programmer wants to do, the hardware is like, "Should I draw sprites this frame? y/n". And that's it. To "not draw" a sprite, you have to actually set its y position below the screen (or make it use an entirely transparent tile, but then it will still count against the 8 sprites per scanline for the sprites you might actually want drawn), but either way it's like... still being drawn.
Flickering is caused by the programmer changing which sprites are the "extras". So if draw call means ensuring all sprites of his head are drawn first so that none are ever considered extras, that's possible. As well, it's possible to make only whole objects not be drawn instead of random parts of them going in an out. Either one doesn't really take more CPU time (some methods might take longer to actually implement, but they'll generally run just as well on the hardware), it just depends on what behavior you want. Some games decide the player character should NEVER disappear (which as you stated means the enemies usually will much more). Even more off topic: Maybe some day I'll make some actual ROMs to throw into the
giant guide, so people can just run the rom in an emulator and press some buttons to how 8x16 sprites work, or how different flickering methods look or whatever else. I guess the text is pretty dense.
Sorry I'm always
that guy about this stuff, but with all the posts going back and forth on this... here's what really happens.
Edit: WOAH! I've been using that image for years, and I only just realized it seems broken, hah. 0x20 (which is supposed to be white) is also drawn transparent. I guess I'll fix that. Regardless, Megaman's sprite layering is a single extra sprite for him, so it wouldn't affect sprites per scanline much. (It's probably one sprite precisely because of that.)
Edit 2: Oh... maybe not. It's not white, just a color that's REALLY close to the current forum background.
Edit3: Okay, one more edit. Even though in the above image the parts of the helmet are transparent to make room for the "face", this isn't necessary. Those could be non transparent, and it would still work with one caveat: The face must always be drawn on top or the non transparent parts of the helmet would show through, which is harder to manage when you're constantly changing the draw order to get around 8 sprites per scanline. With the way Megaman did it, draw order doesn't matter. But it's certainly possible to layer even over non transparent stuff, it just requires some extra checks. (which don't affect CPU time much either.)