It's been a while (uhhh... 17 years) since I last participated in any kind of Cemetech contest, but screensavers sounded like an interesting concept- I had more than a few ideas shortly after the contest was announced.


WEB1999 is inspired by the Web experience prior to the turn of the millennium and a large dash of a certain Flash game from 2002. You're not guaranteed to have fun or learn anything from it, but you might manage to extract both of those benefits from it anyway.

"Prototype 3":



Anachronistic update from downthread: http://ceme.tech/DL2402
Doing up some graphics and sorted out what I need to have a variety of kinds of windows for it to select from when spawning new ones:

I'm quite pleased with the WordArt (very 90s!), and hope the ~3KB of memory needed for it as graphics doesn't become problematic; seems like it'll be okay because I'm not planning on that many different kinds of windows. Eagle-eyed viewers might recognize the "broken image" icon as coming from Netscape Navigator which is a little archaic for the supposed time for this screensaver to "take place" (by 1999 Navigator was well on the way out, being displaced by IE 5), but I think it's more iconic than the alternatives (such as IE's simple red X).

Haven't yet figured out what I'll do about ensuring performance remains okay when there are multiple windows onscreen (especially when one of them is being moved), but maybe it won't be an issue. Have ideas for if it turns out to be important, anyway.
I absolutely adore the broken image callback, 110% needed here.
This is super cool. As I'm sure you're aware, I've been doing a fair amount of work on GUI libraries/window managers on the CE over the past few years with VYSION 1/2 and other projects, so I feel obligated to ask for any implementation details you're willing to share--how powerful is whatever system you've made for this?

And you've pretty much nailed the Windows 9x aesthetic, nice job with that. Look forward to more updates!
I remember making prank programs in VB5 back in the day that would ask a question like "Do you want to delete your files?" And have the No button swap with yes when you mouseDown etc lol - then it would should a filelist of your actual files being 'deleted' but really it was just removing the text from the file list.

This looks fantastic 🤣
epsilon5 wrote:
This is super cool. As I'm sure you're aware, I've been doing a fair amount of work on GUI libraries/window managers on the CE over the past few years with VYSION 1/2 and other projects, so I feel obligated to ask for any implementation details you're willing to share--how powerful is whatever system you've made for this?

I'd characterize it as "not very sophisticated", but it might be more than you expect despite that. The main primitive in use is a rectangle with strictly non-negative x and y coordinates (windows never fall off the top or left edges of the screen) and fixed width+height. A few different functions do computations with magic numbers to return rectangles describing the titlebar (to drag the window around), close button (to close it) and content area (making it easier to draw the content).

When drawing a window, a base function draws the window decoration and optionally fills the content area with a chosen color. Specific windows (like the above-pictured "hot singles" one) provide their own function to display things in the content area, and the window has fixed size chosen to be large enough to contain all the content. Notably, scrolling is completely unsupported because none of this is actually interactive; it just looks like it could be interactive.

The trickiest part so far was actually handling cursor movement, since it needs to identify what control to move to then actually move there in a fairly straight line and ideally at configurable speed. I studied Bresenham's Line Algorithm some and played with iterative versions of that before starting from scratch and somewhat by accident constructing an algorithm using fixed-point arithmetic (something like 16 bits of integer part and 7 bits of fractional part) and error accumulation that conveniently handles moving in any direction. The result seems easier to understand than adapting Bresenham's algorithm to correctly operate in any octant, though it does use multiplication (but not division, unless you count a line that's written as division by 128 because C doesn't have a right arithmetic shift on signed numbers) so wouldn't be very fast on very small CPUs; eZ80 is probably fine though since we get the mlt instruction.
A little Easter egg that I wasn't sure if it was out of date by 1999, but at least an ngram comparison of "at power supply" vs "atx power supply" indicates ATX was still replacing AT as of 1999; APM arrived in 1992 and ACPI in 1996 so certainly self-off capabilities existed well before 1999, but it seems likely that at least some newish machines at the time still lacked either.


I also nerdsniped myself a bit with colors: now the color palette is limited to the basic 16 colors defined by HTML 4.01, plus the 216-color "web-safe" palette and a few extra "system" colors that make the UI decorations look better. This probably isn't noticeable, but it should maximize verisimilitude.
I always loved window managers and other things that look like old-school Windows like this animation. Thank you for the trip back down the memory lane with this contest entry project. This looks pretty good Smile
Sorted out machinery for handling multiple windows and associated logic for choosing which window to interact with, so now you're getting more of a "kill the popups" experience:


One thing that these new features highlight is that moving the cursor at a constant fraction of the needed distance for each tick makes it look bad when it needs to do very short moves; this can happen more often now because it needs to recompute the needed move every time a new window appears. I'll probably do something easy to make short moves complete faster, but this is probably also a good time to add some randomization to the cursor speed.

I'm also not super pleased with how windows often end up off the right side of the screen, so either I need to bias it to avoid doing that nearly as much, or allow them to hang off the left side so it's more balanced.
This is a a good and fun idea !!!
Really enjoy.
It reminds me the good old time of netscape and 56k modems !!!
a, this is a million years ago !!!
I now have eight different popup types and tweaked window placement so they're biased more towards the center of the screen and won't go very far offscreen in the occasional cases where they are going off the edge. Also tuned the spawn rate further after those changes so on average there will be more than one window visible.

I also had a somewhat interesting time working around a compiler bug where an object larger than 127 bytes sometimes causes the compiler to emit index register offsets that are out of range (going further than IY+127) which fails to build.
Very neat. Gives a very retro aesthetic, would definitely have this on my calculator. Could a few be larger or smaller than the need to be randomly and be clipped or floating in the middle of a bigger space? Also, could there be a setting for different background colors?
You closed the one that said you won #1,000,000! Don't do that you need to contact them!

Lol this is great Very Happy.
This concept is so great. It definitely reminds me of some old early flash animations that used Windows 98 screencaps.
I'm nearly out of ideas for popups right now, which is fortunate because the program is nearing reasonable size limits as well, at least for debug builds.


I looked at the pieces that go into rendering each window and pulled out a set of operations which could be expressed as bytecode that I think will allow window definitions to be smaller; for HotSingles, bytecode is around 5 times smaller than machine code and including the bytecode interpreter the break-even point in size is probably only at number_of_windows=3. This approach would also allow windows to be loaded from external sources so it would be easy to put custom popups in appvars and automatically have them appear, which would be neat for unlocking others' creativity once I'm done with this.
Compiling easily-written window descriptions into bytecode will require some work on tooling though, so I'm not confident I'll be able to get that implemented before the end of the contest but that's probably a feature I'd want to include for a proper "1.0" release.
This is getting better and better at every update.
Nice !!!
Amazing work!! I like the overall graphics and how everything is coming along.
In the Cemetech archives: https://www.cemetech.net/downloads/files/2402
Source repository: https://gitlab.com/taricorp/web1999

I spent a while writing up a detailed README that includes illustrative images and a variety of references into the research I did to ensure I wasn't including anything that was anachronistic or too old to represent the state of the web around 1999; I'm pretty proud of that as well as the mostly-automated release process I set up (run make release and it compiles the program, generates the nice HTML and plaintest READMEs, packages it up into a zip file with appropriate version tags).

I also submitted a special contest version (v0.1c) as my contest submission, because I wanted the program to show a credits screen on first run. Normally it'll stay there until you press any key to begin the screensaver proper (and at that point the credits screen is just another window and will be closed automatically), but since the contest information said submissions would be judged without any interaction I made it show the credits for only 15 seconds before beginning automatically in v0.1c. If I decide the time limit is nicer overall I might retain that for future releases, but don't currently plan to.
As someone who was around back then this looks amazing 😀😀😀
Tari wrote:
Compiling easily-written window descriptions into bytecode will require some work on tooling though, so I'm not confident I'll be able to get that implemented before the end of the contest but that's probably a feature I'd want to include for a proper "1.0" release.

I've prototyped out a bytecode compiler that is capable of loading images and converting them to sprites in the correct palette (which is the hard part), with the actual window description written in Lua embedded in a Rust program. This particular choice of technologies comes from Lua being easy to embed, and it's easy to do all of the image manipulation and quantization in Rust.

I've also prototyped a web-based editor that runs the Rust bytecode compiler (run client-side as a wasm program) and renders the resulting bytecode using much of the same rendering machinery as will eventually end up in the calculator binary as well (so it reuses most of the code for rendering, also a wasm program).
  
Register to Join the Conversation
Have your own thoughts to add to this or any other topic? Want to ask a question, offer a suggestion, share your own programs and projects, upload a file to the file archives, get help with calculator and computer programming, or simply chat with like-minded coders and tech and calculator enthusiasts via the site-wide AJAX SAX widget? Registration for a free Cemetech account only takes a minute.

» Go to Registration page
Page 1 of 2
» All times are UTC - 5 Hours
 
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum

 

Advertisement