Spectrum Computing

Dang it, that’s impressive.

https://www.youtube.com/watch?v=anUof69RNJI
Link (in case the video doesn’t work for you).

Dang it, that’s impressive.

Yes, it's a cool and advanced demo. Some graphics are inspired by the game Extreme.

Yes - cool demo. I like the jiggery-pokery (or should get be jiggery-PUSHery?), but the graphics are most impressive.

R-Tape wrote: ↑Mon Apr 08, 2019 9:46 pm Yes - cool demo. I like the jiggery-pokery (or should get be jiggery-PUSHery?), but the graphics are most impressive.

I couldn't even really see the attributes scrolling either though, really smooth. Having said that, I might be one of those people with low fps eyesight.

DouglasReynholm wrote: ↑Mon Apr 08, 2019 11:48 pm I couldn't even really see the attributes scrolling either though, really smooth. Having said that, I might be one of those people with low fps eyesight.

I thought the same thing, but your eyes are fine - that's a multicolour scroll, so it IS that smooth.

Yes, there is multicolour in several places in that demo. The scroll which we are talking about seems to use 8x2 multicolour, that is an attribute is assigned to 8x2 pixels area.

Wouldn't be so impressive as it was done several times before and even Nirvana engine uses 8x2 multicolour in full screen mode and here we have it only on a part of the screen.

But think about the scroll. Each frame it has to read and write both graphics and attributes. A lot of work, a lot of PUSH/POP stuff.

Maybe similar stuff was done before. Check Eye Ache 2 demo (below) But it's still impressive as hell, especially if you know the limitations. https://www.youtube.com/watch?v=6_27EJjjt48

There are a lot of LDIs and plain LDs in there as well. It looks like the PUSHes are mainly used for the parallax bars and the multicolour scrollers (the text on the right-hand side of the screen is also a multicolour scroller).

They've got an interesting attribute scrolling routine: due to the lack of registers available, it doesn't use a loop counter to detect when it reaches the bottom of the screen, but instead does a RET with SP pointing to a table of code addresses. This way the PC will normally just advance to the next unrolled loop iteration, but goes somewhere else when the loop is done. (I suppose there's some reason why a self-modifying JP wouldn't work?) PUSH AF is used to draw the first two columns, as only 15 columns are actually visible and the first is always black. (The routine doesn't modify any flags so F is always zero, but maybe this isn't necessary if the underlying bitmap is invisible?)

Did this one back in January, mostly so it could be converted to Amstrad and Commodore. It's a standalone version of one of the embedded mini-games from Microfair Madness 128K.

The Great Caravan Caper
http://8bitag.com/games/caravan.html

A Little Fish Big Tale by Gabriele Amore:

https://www.worldofspectrum.org/forums/ ... ame#latest
https://www.youtube.com/watch?time_cont ... SGQs6-5vek

Scrolling multicolour attributes is fairly easy - you have to redraw all the attributes every frame anyway, so changing what is drawn isn't usually much of a problem. My first multicolour demo scrolled. The trick is updating all the pixel data to match, which I didn't do - I just used a patterned background and let the attributes roll over it, with the occasional sprite drawn in during top-border time then erased in bottom-border time.

In this demo, it's only half the screen width (or less) like 8x1 multicolour, but it's actually 8x2 attributes. That means for every two lines of the screen being displayed, it can (a) change one line of attributes and (b) re-write one line of pixels. That achieves 8x2 multicolour with half the pixels re-drawn; the other half must be re-drawn during top & bottom border-time.

What inhibits scrolling is if all the addresses for each line of the multicolour routine are hard-coded; that makes them harder to change. Nirvana does this out of necessity, to have time to re-write the whole row of attributes. My River Raid scroller encoded the address of the next line of data after each row of attribute data, so it could be obtained with an extra POP. So you could point your multicolour processor to any line in the buffer, and it would not only display the buffer from that point on, but automatically wrap-around, from the bottom of the buffer to the top. But then it wasn't as wide a multicolour band.

As for terminating the colours conditionally, the Buzzsaw+ menu does something like this. It's a loop, and at then end of the colour buffer, the FLASH bit is set in a last dummy line of the attributes, which is POPped into AF, thus setting the SIGNED flag in F straight away, so a simple RET M will then exit. (Actually what I do is run onto a second multicolour routine, that splits the colours on the bottom row to show the high-score, then exit after that). But it's an efficient way of doing looped mutlicolour rather than unrolled as you don't need to DEC or even test a value - the flag is set during the POP of the colour data.

Thanks for the explanations, it's always intriguing to hear about stuff like this.

(Derailing the topic further) I was just reminded of this (mostly) full-screen multicolour scrolling demo that looked quite promising. Only the author pre-calculated everything on a PC beforehand and it's non-interactive. It would be really cool if something like that were able to run in real time, but I guess it would be too much for the Speccy to handle.

EDIT: Interesting game too, reminds me of Scuba Dive. And the tiny sprites are quite nicely designed.

djnzx48 wrote: ↑Tue Apr 16, 2019 11:27 pm It would be really cool if something like that were able to run in real time, but I guess it would be too much for the Speccy to handle.

Did you miss this?

That's a different technique isn't it? The tech demo is using 28 columns of the screen and it's doing horizontal scrolling as well. Granted, it's not 8x2 multicolour or even 8x4, but surely it's a lot of work doing all that pixel scrolling at 50fps?

Horizontal scrolling isn’t difficult as far as color attributes are concerned if the background is just solid black. You just need to swap the ink and paper colors at cell boundaries. The scrolling itself at 50 fps is pretty impressive, I agree, but the active window size is fairly small.

Hikaru made a truly impressive horizontal scrolling multicolor demo soon after we sorted out the floating bus business:

https://www.youtube.com/watch?v=wE1KylKQDrQ

It’s interactive, too, if I recall correctly, that is, you can use keys to scroll in either direction.

Ninjaman is pretty simple, not sure why they need so complex approach with pc calculations. Look carefuly, only 1 attribute value per horizontal line with hole in center for hero sprites. Hero sprite always at center of screen.Very limited.

Also making a demo it's just a 10% of work, you still need to implement gameplay. It need to reserve some cpu power for gameplay otherwise it never become a game, just another uniteractive demo!

And my personal favourite is this one: https://zxart.ee/rus/soft/demoscene/skyscraper/
It does full screen vertical scroll. Unfortunately it's pentagon timings only

Cheers!

And my personal favourite is this one: https://zxart.ee/rus/soft/demoscene/skyscraper/

Very nice, funny demo. Thanks for mentioning it, somehow I missed it when it was released

The problem with scrolling comes when you want to add sprites.
In Cobra, the screen is redrawn directly from the level map using fast PUSH techniques, then sprites are drawn in before the raster comes round again.

With multicolour, that catches you out. You could draw the colours for the scrolling scenery live in step with the raster, based straight off the level map, but then you can't fit the sprites in with their own colours. You could skimp on details and make all your sprites use the same bands of colour, then define that as your 'empty' map cell, but your cheapness would show! The other way round it is to paint the colours to a buffer, then add the sprites, then render the multicolour from the buffer, but that takes twice as long to do all the attributes.

On the other hand, with horizontal scrolling, you only need to completely scroll the scenery attributes once per whole character that is scrolled, so you might have four or eight passes through your routine to redraw the background attributes in a new buffer, then switch over to it instantly. To add moving sprites to that though, you need to be able to add them then delete them and restore the bit of the buffer where they were, while you work on building up the new buffer.

New demos from Revision 2019:
http://www.pouet.net/party.php?which=1550&when=2019

Rade Blunner, a platform made with the Churrera V1.

Rade Blunner, a platform made with the Churrera V1.

Well, very standard for Churrera, I guess.
I'd love to see a GOOD Spectrum game inspired by Blade Runner but it's not going to happen yet this time

Alessandro wrote: ↑Mon Apr 22, 2019 11:33 am Rade Blunner, a platform made with the Churrera V1.

Cool. Is anyone in touch with this author? Could they check their ZXDB permission stance pleez

R-Tape wrote: ↑Mon Apr 22, 2019 10:13 pm Cool. Is anyone in touch with this author? Could they check their ZXDB permission stance pleez

I did that, let's wait for an answer.

R-Tape nice to meet you, I am iadvd, please be free to add Rade Blunner to the ZXDB,
by the way, there is an explanation of the game in English here:
https://github.com/Iadvd/Retrocomputing ... adeBlunner

-Alessandro: many thanks for your message!

Best Regards,

iadvd wrote: ↑Wed Apr 24, 2019 9:18 am R-Tape nice to meet you, I am iadvd, please be free to add Rade Blunner to the ZXDB,

Ta very much! It'll be in the next update.