FEED Validator

for Atom and RSS and KML

Congratulations!

This is a valid RSS feed.

Recommendations

This feed is valid, but interoperability with the widest range of feed readers could be improved by implementing the following recommendations.

line 9, column 100: Self reference doesn't match document location [help]

...  rel="self" type="application/rss+xml"/>
                                             ^

line 619, column 0: description should not contain iframe tag [help]

&lt;iframe src=&quot;https://audio.com/embed/collection/1772150151033320?the ...

Source: http://feeds.feedburner.com/ReidsForFun

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0"
xmlns:atom="http://www.w3.org/2005/Atom"
xmlns:dc="http://purl.org/dc/elements/1.1/"
>
<channel>
<title>Reid’s For Fun</title>
<link>https://www.reids4fun.com</link>
<atom:link href="https://feeds.feedburner.com/ReidsForFun" rel="self" type="application/rss+xml"/>
<description>Reid’s For Fun - Latest News</description>
<language>en-us</language>
<lastBuildDate>Sun, 10 Mar 2024 11:42:00 -0600</lastBuildDate>
<image>
<title>Reid’s For Fun</title>
<link>https://www.reids4fun.com</link>
<url>https://www.reids4fun.com/images/r-badge.png</url>
</image>
<item>
<title>Crafting Black Hole Graphics on the ZX81</title>
<link>https://www.reids4fun.com/561/crafting-black-hole-graphics-on-the-zx81</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Sun, 10 Mar 2024 11:17:00 -0600</pubDate>
<category>ZX81 Computer</category>
<category>monthly</category>
<category>zx81</category>
<category>retro</category>
<category>basic</category>
<category>daric</category>
<guid>https://www.reids4fun.com/561/crafting-black-hole-graphics-on-the-zx81</guid>
<description><img src="https://www.reids4fun.com/images/zx81/blkhole-2023-zx81-screenshot-3-by-steven-reid-320x240.png" alt="Black Hole, ZX81 Screenshot 3, 2023 by Steven Reid" style="float:left;margin-right:10px">I had forgotten about this Black Hole program until I ran across it while cleaning up some directories. It is a conversion, not an original, program that was shared on one of my BASIC forums. It doesn’t look quite as good as the original, but it was interesting <a href="https://www.reids4fun.com/zp/blkhole" target="_blank" rel="noopener">to see what the ZX81 could do with its simplistic graphics</a>.# Having some BASIC fun.
 
“Black Hole,” by Dusty W. Murray, intrigued me because it already produced black and white output. Although, in the original version, the background is black. It creates a simple swirling pattern that resembles a black hole, and generated quite a lot of participation on the group at the time. 
 
My first attempt, however, was not for the ZX81. I decided to try this in Daryl Dudey's Daric BASIC first, and it worked well. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/memberpics/admin/blkhole-2023-daric-screenshot-by-steven-reid.png" alt="Black Hole, Daric Screenshot, 2023 by Steven Reid">Black Hole, Daric Screenshot, 2023 by Steven Reid</div>
 
 
Here is the Daric BASIC code for those interested. I added the range command, and the images look much nicer! This version will generate images until you press <kbd>q</kbd>. 
 
<pre>rem **Black Hole**by Dusty W. Murray**
rem **Converted to Daric by Steven Reid, 3/19/2023**
Def Range:float(v:Float, minimal:Float, maximal:Float)
if v&amp;lt;minimal then v = minimal
if v&amp;gt;maximal then v = maximal
return v
End Def
Mode 800,600,Windowed
SetBg 0, 0, 8
SetFg 255,255,255
w = ScreenWidth()
h = ScreenHeight()
mw = int(w/2)
mh = int(h/2)
mr = mw * 2
Repeat
Cls
ads = 0.005
rds = 0.5
r = 5.0
rd = 0.0
a = 0.0
ad = ads
For t = 0 To 1999*31
ch = Rnd(5)
if ch = 0 then rd = rds
if ch = 1 then rd = -rds * 0.991
if ch = 2 then ad = ads
if ch = 3 then ad = -ads
r = r + rd
r = Range(r, 10, mr)
a = a + ad
if a&amp;lt;0 then a=a+2*pi
if a&amp;gt;2*pi then a=a-2*pi
ar = r / 50
x= int (Sin(a+ar)*r) + mw
y= int (Cos(a+ar)*r) + mh
Plot x,y
Next
key = GetKey() : rem Wait for a key
Until key=113 : rem Quit on &quot;q&quot; being entered</pre> 
 
# Giving the ZX81 a try. 
 
Given that the ZX81 has pretty good math, <a href="https://www.reids4fun.com/zl/blkhole" target="_blank" rel="noopener">converting this to ZX81 BASIC wasn’t too hard</a>. I started with my Daric version and added in line numbers. Most of the statements were already on separate lines, making it easy to convert. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/blkhole-2023-zx81-screenshot-1-by-steven-reid-320x240.png" alt="Black Hole, ZX81 Screenshot 1, 2023 by Steven Reid">Black Hole, ZX81 Screenshot 1, 2023 by Steven Reid</div>
 
 
I did inline the <code>Range</code> function as the ZX81 doesn't have a mechanism to do that. The final code looks similar to the original, with a few more comments to make things obvious. I also broke out the loop into two parts. This was so I could use the <code>FAST</code> command to speed it up a bit. After each iteration, I <code>PAUSE</code> for a bit so you can see the image progression. 
 
You’ll also notice the function boundaries are quite a bit lower than the original. This is due to speed as well as the smaller screen size. I also created a PI2 variable that equals 2×π (2*PI in Sinclair BASIC). This reduces the overhead of multiplication where possible. 
 
# Making adjustments 
 
Coming back to any program, you often see things you missed. In my case, I saw a minor bug in the range code that needed fixing. In doing so, I took another look at the math. The ZX81 version didn’t quite look as nice as the original, and I wanted to see if I could improve it. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/blkhole-2023-zx81-screenshot-2-by-steven-reid-320x240.png" alt="Black Hole, ZX81 Screenshot 2, 2023 by Steven Reid">Black Hole, ZX81 Screenshot 2, 2023 by Steven Reid</div>
 
 
Using the Daric version for testing, I reverted the variables and started adjusting each individually. This helped me determine what each one did. My goal was to shrink down the output to fit the ZX81’s smaller screen. 
 
To make it a bit easier to adjust, I refactored my ZX81 program to move the variables into their own subroutine. I also found that adjusting the division factoring when setting the AR variable made the most difference. Thus, I turned that into the RS variable to make it easier to adjust. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/blkhole-2023-zx81-screenshot-3-by-steven-reid-320x240.png" alt="Black Hole, ZX81 Screenshot 3, 2023 by Steven Reid">Black Hole, ZX81 Screenshot 3, 2023 by Steven Reid</div>
 
 
As a side effect of the changes, I found that I didn’t need as many iterations. The program tended to move out of the screen boundaries after about 5 or so iterations, but a few would go longer. I chose 10 as a compromise. 
 
# Out the other side. 
 
Black Hole isn’t perfect on the ZX81, but it still generated some interesting images. I’m sure I could improve it to make better-looking black holes. But for a super slow ancient computer, it still generated interesting pictures. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/blkhole-2023-zx81-screenshot-4-by-steven-reid-320x240.png" alt="Black Hole, ZX81 Screenshot 4, 2023 by Steven Reid">Black Hole, ZX81 Screenshot 4, 2023 by Steven Reid</div>
 
 
If you want more of ZX81 screensaver, it is a pretty easy modification. Comment out the <code>FAST</code> on line 60 and adjust the <code>PAUSE</code> on line 280 to 5000. You can also comment out the <code>PAUSE</code> on line 260 if you desire. This will give you a continuous display that can be quite fun to watch. 
 
In the end, the most fun was programming in a different BASIC dialect other than Sinclair. I hadn’t done that since Amiga BASIC back in the earlier 90’s. The code is quite similar to that and probably would work well on the Amiga. That would be a fun trip down memory lane, but I leave it for another day. For now, you can enjoy the ZX81 version.</description>
</item>
<item>
<title>ZX81 Aquarium Makeover—Revamping Kimmie Fish in Assembly</title>
<link>https://www.reids4fun.com/560/zx81-aquarium-makeoverrevamping-kimmie-fish-in-assembly</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Sun, 18 Feb 2024 11:44:00 -0600</pubDate>
<category>ZX81 Computer</category>
<category>zx81</category>
<category>retro</category>
<category>monthly</category>
<guid>https://www.reids4fun.com/560/zx81-aquarium-makeoverrevamping-kimmie-fish-in-assembly</guid>
<description><img src="https://www.reids4fun.com/images/zx81/aquarium-2024-zx81-screenshot-1-by-steven-reid-320x240.png" alt="Aquarium Screenshot 1, 2024 by Steven Reid" style="float:left;margin-right:10px">While on vacation, I spent some relaxing time converting my Kimmie Fish BASIC program into <a href="https://www.reids4fun.com/zp/aquarium" target="_blank" rel="noopener">something a bit more interesting</a>. In addition to the normal speed improvements, I wanted to give it an aquarium like feeling with bubbles and depth. No color here, this is all stock ZX81 graphics. Only thing needed is the requisite 16K memory pack.
 
# A fine screen saver indeed. 
 
Before digging into the display, let's look a bit at what all Aquarium does. There is a bit of subtlety to the program that you might not notice at first glance. For example, the fish start off at full speed. After that, their speed will vary to make the visuals a bit more random. The speed difference isn’t huge but is noticeable. 
 
The bubbles range not just in size but speed as well. The little bubbles tend to move slowly. The larger bubbles tend to move quickly. In relation to each, they also take on some variability in speed. This keeps the screen moving and avoids becoming repetitive. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/aquarium-2024-zx81-screenshot-1-by-steven-reid-320x240.png" alt="Aquarium Screenshot 1, 2024 by Steven Reid">Aquarium Screenshot 1, 2024 by Steven Reid</div>
 
 
Although it may not be obvious at first, there is also depth in the scene. The tiny bubbles are in the back. The Kimmie fish are in the middle, overwriting any small bubbles. The large bubbles are in front and will overlap the fish. it doesn’t happen often, but is noticeable when it does. 
 
You can actually break out of the program by pressing the <kbd>SPACE</kbd> key as normal. Each run of the program will generate different water and sand graphics. Sharing with friends, they liked the overall effect and I do as well. 
 
# From simple to complex. 
 
Converting <a href="https://www.reids4fun.com/559/how-i-made-a-kimmie-fish-swim-on-the-zx81" target="_blank" rel="noopener">original BASIC version</a> wasn’t really an option. That version used string manipulation to determine what would display not he screen. That didn’t make sense here. Plus I had a lot more flexibility here due to the speed gains. 
 
The main loop is actually straight forward (below), but <a href="https://www.reids4fun.com/za/aquarium" target="_blank" rel="noopener">the code is more complex</a> than I expected it would be. 
 
<pre>        call initialize
main_loop:
        call move_back_bubbles
        call move_fish
        call move_front_bubbles
        call copy_to_screen
        jr main_loop            ; rinse and repeat</pre> 
 
Reading above, you get an idea of how I managed the death. Each element is printed back to front, overwriting the previous graphics. This provided a sense of depth without a lot of trickery. The display is done in a buffer that is copied to the screen when done to avoid flickering. To keep the frame rate somewhat consistent, I used the frame counter for the delay. it’s not perfect but works. 
 
# Making fish move. 
 
To deal with the movement of the fish, I decided to treat them as sprites. The BASIC program used strings, but I have a lot more control here. I don’t actually do any string slicing. Instead, the routine that prints the character into the buffer checks if either the <var>X</var> or <var>Y</var> coordinates are out of range. If they are, it returns without printing anything. 
 
By doing the bounds check, I could allow the X position to move outside of the screen until the fish was completely off screen. To avoid having to clear the buffer, the sprite has spaces to print over the end of the fish. This has the advantage of speeding up the program with minimal memory impact. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/aquarium-2024-zx81-screenshot-2-by-steven-reid-320x240.png" alt="Aquarium Screenshot 2, 2024 by Steven Reid">Aquarium Screenshot 2, 2024 by Steven Reid</div>
 
 
Once the fish is off screen, I do a quick call to reposition it (see below). It is a bit brute force as it just calls a random value and then checks if the fish is on the other fish. I could have allowed them to overlap, but decided I didn’t like the way the graphics displayed doing that. 
 
<pre>get_fish_row:
        ld b,buffer_size-2
        call rnd        ; from 1 to buffer_size-2
        dec a           ; make from 0 to buffer_size-3
        ld b,a          ; save new pos
        ; check if other+2 &amp;lt; top (top&amp;gt;e+2 or e+2 &amp;lt; top)
        ld a,e
        add a,2
        ld d,a
        cp b
        jr c,good_to_go
        ; check if top+2 &amp;lt; othertop
        ld a,b
        add a,2
        cp e
        jr nc,get_fish_row
        ; we are good!
good_to_go:
        ld a,b          ; restore position
        ret</pre> 
 
Funny enough, this was probably the hardest part to get right. I had to futz with tests a few times to makes sure they were working correctly. Funny how simple things can be hard. 
 
# Adding speed. 
 
The bubbles, much like the fish, are stored in an array. To mimic speed, I actually use two bytes to determine if the bubble moves. The first byte is the speed. The second is the sub-position. 
 
To move the bubble, I first add the speed to the sub-position. If the sub-position rolls (sets the carry flag), I move the bubble. Otherwise, the program saves the sub-position and keeps going. I used the same logic for the fish as well. This allows a more organic movement. You can view this on <a href="https://youtu.be/Mj_cOD53Bv4" target="_blank" rel="noopener">YouTube</a> as well. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/aquarium-2024-zx81-movie-by-steven-reid-320x240.gif" alt="Aquarium, Video, 2024 by Steven Reid">Aquarium, Video, 2024 by Steven Reid</div>
 
 
This is different from how I managed speed in my <a href="https://www.reids4fun.com/543/zx81-digital-rain-a-retro-display-of-the-matrix-code" target="_blank" rel="noopener">ZX81 Rain</a> program. In that one, I had a frame counter that I would increment. When that counter reached the speed, it would reset to zero and move the drop. This version doesn’t require reseting the variable. 
 
One thing I realized afterwards is that I update the fish frame each print. This makes the slower fish look like they are swimming against a current. Reviewing the code, it wouldn’t have been a hard change to make either. Consider it a bug to correct in a future version. 
 
# Improving and final thoughts. 
 
Although I love the look of the aquarium, it could be more. My original idea was to add in different backdrop objects like rocks, plants or figures. I also thought about moving the water a bit with a pump at the top. As the program progressed, I felt those elements weren’t needed. 
 
The fish code isn’t very optimized. My original goal was to add different fish types. The sprites would then be picked when adding the fish. The problem is I didn’t like the graphics I came up with. The whole left/right fish thing could be done completely different. End in the end, it was easier calculating them in separate code blocks. 
 
The final result is pleasing and I’m happy with what I put together. The code is readable and should be easy enough to adjust in the future. 
 
</description>
</item>
<item>
<title>How I Made a Kimmie Fish Swim on the ZX81</title>
<link>https://www.reids4fun.com/559/how-i-made-a-kimmie-fish-swim-on-the-zx81</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Tue, 30 Jan 2024 15:55:00 -0600</pubDate>
<category>ZX81 Computer</category>
<category>zx81</category>
<category>retro</category>
<category>monthly</category>
<guid>https://www.reids4fun.com/559/how-i-made-a-kimmie-fish-swim-on-the-zx81</guid>
<description><img src="https://www.reids4fun.com/images/zx81/kimmie-fish-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="Kimmie Fish, 2023 by Steven Reid" style="float:left;margin-right:10px">Reading posts in the BASIC group I follow, I was I was inspired to write my own version of the kimmie fish animation for the ZX81 computer. It was such a cute animation that I had to see if I <a href="https://www.reids4fun.com/zp/kimmie" target="_blank" rel="noopener">could replicate it</a>. Although not quite the same as the original, the spirt is there.
 
# Getting started. 
 
Although the original version was written using BASIC, it was using commands not available on the ZX81. That usually isn't too big an issue as I can convert most. But in this case, it used graphic commands and a line generator. Although possible to replicate, it would make the animation extremely slow. Fortunately, there was a solution. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/kimmie-fish-2024-sprite-frames-by-steven-reid-320x240.png" alt="Kimmie Fish, Sprite Frames, 2023 by Steven Reid">Kimmie Fish, Sprite Frames, 2023 by Steven Reid</div>
 
 
I realized that I could replace the line drawing routines with character graphics. Not only would it be faster, but it would simplify the program. I whipped up some sprites and got to work building the program. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/kimmie-fish-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="Kimmie Fish, 2023 by Steven Reid">Kimmie Fish, 2023 by Steven Reid</div>
 
 
# Coding it up. 
 
<a href="https://www.reids4fun.com/zl/kimmie" target="_blank" rel="noopener">The code</a> was pretty straight forward. I started with a <code>GOSUB</code> to setup the screen and variable. I built a routine to for the aquarium—something not in the original. Having programed a number of animations in ZX81 BASIC, I decided to use a string array. More on that in a bit. 
 
In actuality, I had two arrays. One for the fish moving right, and one left. The advantage of that was each fish prints over itself so I could avoid a double buffer. This kept the routine reasonably fast. But it had another advantage. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/kimmie-fish-2023-zx81-screenshot2-by-steven-reid-320x240.png" alt="Kimmie Fish, 2023 by Steven Reid">Kimmie Fish, 2023 by Steven Reid</div>
 
 
The problem I had to deal with was the fish swimming off screen. This was the advantage of using a string array. As the kimmie fish reached an edge, I would only print the part of the array that was visible. Although straightforward, it took time and testing to work out the math. Here is the routine. 
 
<pre> 30 REM **MAIN LOOP
  40 LET LS=(-D+1 AND D&amp;lt;0)+(1
AND D&amp;gt;=0)
  50 LET LE=(6+(26-D) AND D&amp;gt;25)+
(6 AND D&amp;lt;26)
  60 LET DX=(0 AND D&amp;lt;0)+(D AND D
&amp;gt;=0)
  70 LET RS=(-B+1 AND B&amp;lt;0)+(1
AND B&amp;gt;=0)
  80 LET RE=(6+(26-B) AND B&amp;gt;25)+
(6 AND B&amp;lt;26)
  90 LET BX=(0 AND B&amp;lt;0)+(B AND B
&amp;gt;=0)
 100 PRINT AT A,BX;R$(R,1,RS TO 
RE);AT A+1,BX;R$(R,2,RS TO RE);
AT A+2,BX;R$(R,3,RS TO RE)
 110 PRINT AT C,DX;L$(L,1,LS TO 
LE);AT C+1,DX;L$(L,2,LS TO LE);
AT C+2,DX;L$(L,3,LS TO LE)</pre> 
 
Although it looks complex, it is actually straight forward logic. The variables <var>LS</var> and <var>LE</var>, for example, stand for left start and left end. They are the calculated positions within the string array. Since the sprite doesn’t move at the edges, the <var>DX</var> variable is used to stop moving it. The other variables determine position and which frame to display. 
 
# Putting it all together. 
 
The final result is a decent little screen saver for the ZX81. I’m proud of the routine that moves the fish off the screen. In the past I brute forced that with an if statement. This program version is a bit more creative, although I suspect much slower. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/kimmie-fish-2023-zx81-gif-by-steven-reid-320x240.gif" alt="Kimmie Fish, Video, 2023 by Steven Reid">Kimmie Fish, Video, 2023 by Steven Reid</div>
 
 
One thing I didn’t like was that the animation felt a bit jerky at times. The display I rewrote the routine using a string array for the screen. This acted as a sort of double buffer. Although the print felt smoother, it was much slower. I ended up abandoning that solution for the original. 
 
Now, although the BASIC version is nice. I kept thinking about all the ways I could make it better. Not only would assembly be faster, but I could enhance the overall look quite a bit. I’ll share how that came out in a future article. Until then, you can also view the animation on <a href="https://youtu.be/Z4ZVzvcjsPU" target="_blank" rel="noopener">YouTube</a>.</description>
</item>
<item>
<title>Retro Festivities Abound in Creating a Christmas Scene on the ZX81</title>
<link>https://www.reids4fun.com/558/retro-festivities-abound-in-creating-a-christmas-scene-on-the-zx81</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Fri, 29 Dec 2023 22:48:00 -0600</pubDate>
<category>ZX81 Computer</category>
<category>monthly</category>
<category>zx81</category>
<category>retro</category>
<category>christmas</category>
<guid>https://www.reids4fun.com/558/retro-festivities-abound-in-creating-a-christmas-scene-on-the-zx81</guid>
<description><img src="https://www.reids4fun.com/images/zx81/christmas-tree-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="Christmas Tree, ZX81 Screenshot, 2023 by Steven Reid" style="float:left;margin-right:10px">For December, I decided to embrace the Christmas spirit. Inspired by group posts, I created a <a href="https://www.reids4fun.com/zp/xmastree" target="_blank" rel="noopener">Christmas tree and snow scene</a>. It needed a little flair, so I added an animated message to the scene. Very retro program for my ZX81.# Generating Christmas spirt.
 
Fitting the mood, I started with the tree. Based on a routine posted for the tree compilation a few years ago, I modified it to work on the ZX81. The ZX81 can't execute multiple commands on a single line. This required me to expand the routine a bit and center it on the page. Done, right? 
 
Well, not quite. I liked an idea from another post that used varying snowflake sizes. I refactored the program into logical sections and added a new routine to display the snowfall. It's similar to how I’ve generated stars in other programs. In this case, I used <code>RND</code> and a string to print the flakes. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/christmas-tree-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="Christmas Tree, ZX81 Screenshot, 2023 by Steven Reid">Christmas Tree, ZX81 Screenshot, 2023 by Steven Reid</div>
 
 
With that look done, I then worked on the message. Again, it’s much like other animations I’d done as a teenager. I went through a few iterations until I settled on the final message. The message is in inverted characters with rotating stars. Simple enough to make using a pair of print statements. 
 
# Comments and structure. 
 
For some reason, I decided to <a href="https://www.reids4fun.com/zl/xmastree" target="_blank" rel="noopener">focus on program structure</a>. Something that is very different than most of my programs. I have built programs with aesthetics before, but rarely. I was in the mood. 
 
After getting the tree to work, I moved the routine to a subroutine. The initial section of the program consists of a list of routine calls using <code>GOSUB</code>. I reordered things a bit, first printing the screen, then the snow, followed by the tree, and finally the message. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/christmas-tree-2023-zx81-animation-by-steven-reid-320x240.gif" alt="Christmas Tree, ZX81 Animation, 2023 by Steven Reid">Christmas Tree, ZX81 Animation, 2023 by Steven Reid</div>
 
 
There is one I don’t call directly. That one saves the program so that it will run when loaded. I used <code>RUN 70</code> to start the saved program. Once the message loop finishes, the program restarts with another <code>RUN</code>. It looks repetitive, but I don’t have many options in ZX81 BASIC. 
 
# Merry belated Christmas. 
 
And with that, I've conveyed my message. It’s late as I was busy spending time with the family and doing other things. Better late than never. I still like the look, but I would have liked to animate the snow a bit. The ZX81 would be pretty slow with that. It gives me something to work on next year.</description>
</item>
<item>
<title>Using Generative AI to Create Lunar Equestrian Dreams</title>
<link>https://www.reids4fun.com/557/using-generative-ai-to-create-lunar-equestrian-dreams</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Sun, 17 Dec 2023 09:30:00 -0600</pubDate>
<category>Mind the Gap</category>
<category>genai</category>
<category>images</category>
<category>nightcafe</category>
<category>art</category>
<guid>https://www.reids4fun.com/557/using-generative-ai-to-create-lunar-equestrian-dreams</guid>
<description><img src="https://www.reids4fun.com/images/memberpics/admin/JcIIzDM4C8u0tfWtEj3T--1--r7vf9.jpg" alt="Moon horse. AI Generated image, 2023 by Steven Reid" style="float:left;margin-right:10px">Funny enough, I'm still having a surplus of fun creating AI art. Between challenges and random ideas, it's been quite a year. I love reading articles and seeing what other creative minds come up with. Reading "<a href="https://medium.com/generative-ai/this-free-open-source-ai-image-generator-is-challenging-midjourney-ac49ed11e56b" target="_blank" rel="noopener">This AI Tool Combines Stable Diffusion's Level of Control and Midjourney's Image Quality — It's Called Distillery</a>," by Jim Clyde Monge, I was intrigued by some of his images and thought I'd give it a whirl with my own whimsical prompt.
 
# Moon horse. 
 
Outlandish? Unoriginal? Perhaps, but whimsical enough for me to give it a go. Naturally, with my plethora of NightCafe credits burning a hole in my digital pocket, it seemed the perfect testing ground. My prompt was simple: "an image of an astronaut riding a horse on the moon." I normally have a few go-to modifiers that I find bring images to life, but for this experiment, I decided to stick with the original prompt. 
 
The outlandish prompt, which I’m sure isn’t imaginative nor unique, was whimsical enough to give it a go. Of course, seeing I have a plethora of credits on NightCafe, it seemed best to try it out there. I used a simple prompt: ”an image of an astronaut riding a horse on the moon.” This doesn't include my normal modifiers that I find makes better images that are more interesting. 
 
My rationale for excluding my modifiers was twofold. First off, I wanted to see if Stable Diffusion would get close to what Distillery's output was doing. Second, I wanted to allow the AI model more freedom in choice. The randomness of the algorithms can create some imaginative images. The prompt could be shortened further as you don’t need to tell Stable Diffusion to generate an image—you can just describe what you want. Of course, I still dabbled with different AI models to see what worked best with my lunar equestrian vision.
 
<a href="https://creator.nightcafe.studio/creation/JcIIzDM4C8u0tfWtEj3T" target="_blank" rel="noopener"><div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/memberpics/admin/JcIIzDM4C8u0tfWtEj3T--1--r7vf9.jpg" alt="Moon horse. AI Generated image, 2023 by Steven Reid">Moon horse. AI Generated image, 2023 by Steven Reid</div></a> 
 
The final image stole the show. It went beyond my bare-bones prompt, adding a sprinkle of magic without straying into the realm of extra limbs (thank goodness). The monochromatic palette resonated perfectly with the stark emptiness of space, and while the abundance of moons might raise an eyebrow or two about equine respiration, that's a conundrum for another day.</description>
</item>
<item>
<title>ZX81 Prototype: Echoes from the Tower of Love</title>
<link>https://www.reids4fun.com/556/zx81-prototype-echoes-from-the-tower-of-love</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Mon, 04 Dec 2023 22:33:00 -0600</pubDate>
<category>ZX81 Computer</category>
<category>zx81</category>
<category>retro</category>
<category>monthly</category>
<category>late</category>
<guid>https://www.reids4fun.com/556/zx81-prototype-echoes-from-the-tower-of-love</guid>
<description><img src="https://www.reids4fun.com/images/zx81/tower-of-love-chapter-1-1984-zx81-screenshot-by-steven-reid-320x240.png" alt="Tower of Love, Chapter 1, Opening Screenshot, 1984 by Steven Reid" style="float:left;margin-right:10px">I've talked about Tower of Love before, but that was a much different version of the game. That version was all about the intro screen and my initial attempt at the story. I even showed another design I had made. To my surprise, I had <a href="https://www.reids4fun.com/zp/t1" target="_blank" rel="noopener">a third version of the adventure that I started</a>. Time to share!
 
# A little bit of story. 
 
<a href="https://www.reids4fun.com/336/tower-of-love-was-an-ambitious-idea-that-failed" target="_blank" rel="noopener">Unlike the first article I shared</a>, the intro of this game starts with a map. But this is not the same map as that one. I actually found the printout of the map attached to the program. I was surprised and didn’t realize it was for Tower of Love until I read the title. Even better, it had some story. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/tower-of-love-chapter-1-1984-zx81-screenshot-by-steven-reid-320x240.png" alt="Tower of Love, Chapter 1, Opening Screenshot, 1984 by Steven Reid">Tower of Love, Chapter 1, Opening Screenshot, 1984 by Steven Reid</div>
 
 
Okay, it isn’t a ton of story. At least not by modern standards. Given the ZX81 had such limited memory, that shouldn’t surprising. This program with a map and two paragraphs of text weighs in at 2KB or an 1/8 of the available memory. That doesn’t give me much for additional text, graphics or even game mechanics. For that reason alone, I suspect that is why this game didn’t get much further. 
 
# The Story continues. 
 
The story itself isn’t bad. I did clean up the text a bit to fit properly on the screens. The story sets up the map and is open ended. I often wonder what I had planned next. Would I let the player wander that map? Would there be directions and rooms? i really don’t know. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/tower-of-love-chapter-1-1984-zx81-screenshot-2-by-steven-reid-320x240.png" alt="Tower of Love, Chapter 1, Second Screenshot, 1984 by Steven Reid">Tower of Love, Chapter 1, Second Screenshot, 1984 by Steven Reid</div>
 
 
I do like the way the text is presented. Each paragraph fits into the bottom underneath the map. Gives kind of an adventure vibe with text. I give the player time to read and press a button. Sadly, since this is only a couple of paragraphs it repeats pretty quickly. 
 
# The map and more. 
 
I decided to look through my old notebook and actually found the original map. This helped me <a href="https://www.reids4fun.com/zl/t1" target="_blank" rel="noopener">type in the map</a>. It is a long <code>PRINT</code> statement and was a bit of a hassle to line up. Sadly, I couldn’t find any additional notes about the map and how it is used in the game. 
 
<a href="https://flic.kr/p/2pgLPJb" target="_blank" rel="noopener"><img src="https://live.staticflickr.com/65535/53343391130_d9707b0b2d_h.jpg" alt="[Image]"></a><a href="https://flic.kr/p/2pgLPJb" target="_blank" rel="noopener">Tower of Love Map</a> by <a href="https://www.flickr.com/photos/safepit/" target="_blank" rel="noopener">Steven Reid</a>, on Flickr 
 
The minimal nature works for this program. I do think scrolling the text would be more interesting. There are a couple of ways to do that in BASIC, but if I decided to improve I’d probably use machine code. I have a lot of routines to compress text and print it to the screen. The only problem is would this be a text adventure or something else? 
 
Overall it was a pretty fun little program. Not quite the full screen treatment of the original version. But it works.</description>
</item>
<item>
<title>Beyond the Atari: A Pitfall! Simulator for the ZX81</title>
<link>https://www.reids4fun.com/555/beyond-the-atari-a-pitfall-simulator-for-the-zx81</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Sun, 22 Oct 2023 10:41:00 -0600</pubDate>
<category>ZX81 Computer</category>
<category>pitfall</category>
<category>gaming.retro</category>
<category>monthly</category>
<category>zx81</category>
<category>lsfr</category>
<guid>https://www.reids4fun.com/555/beyond-the-atari-a-pitfall-simulator-for-the-zx81</guid>
<description><img src="https://www.reids4fun.com/images/zx81/pitfall-sims-2023-zx81-start-screenshot-by-steven-reid-320x240.png" alt="Pitfall! Simulator, ZX81 Screenshot of the Starting Room, 2023 by Steven Reid" style="float:left;margin-right:10px">While contemplating what ZX81 program to write about this month, I completely forgot that I had created a <a href="https://www.reids4fun.com/zp/pitfallsim" target="_blank" rel="noopener"><cite>Pitfall!</cite> Simulator</a>. It began as a fun project to occupy my time during winter break. My initial goal was to recreate David Crane's LSFR (Linear Feedback Shift Register) in Z80. However, after learning more about its functionality, I took the project much further than I had originally intended.# A Trip Down Memory Lane.
 
<cite>Pitfall!</cite> is a fun game that I enjoyed as a child, although I preferred the sequel, <cite>Pitfall II</cite>. The original game's linear progression felt underwhelming, and the jump timing was finicky. However, it was still a remarkable game that showcased the capabilities of the Atari VCS. It featured action, numerous changing rooms, and a sense of exploration. I particularly enjoyed figuring out how to best avoid those pesky logs, even though they slowed me down. Additionally, I appreciate that this is a game that my wife, who is not much of a gamer, also played. It is a shared piece of nostalgia for both of us.
 
Fun fact, I actually considered creating a <cite>Pitfall!</cite>-like game for the ZX81. I even went so far as to design the rooms and character graphics. However, I knew that working in BASIC, it would not be fast enough. Additionally, I did not understand how the original game was actually built. For my version, I was generating static rooms of content. I quickly realized, even at the age of 14, that I would run out of memory and abandoned the idea. 
 
# Playing with the LSFR. 
 
It should come as no surprise, then, that when I came across an <a href="https://evoniuk.github.io/posts/pitfall.html" target="_blank" rel="noopener">article about <cite>Pitfall!</cite></a>, I was intrigued. The article discussed how David Crane managed to fit 255 rooms into <cite>Pitfall!</cite>. I thought it would be a fun programming challenge to get the LSFR working on the ZX81. 
 
Since the article shared the original LSFR code, I used it as the basis for my version. I had to learn a little 6502 code to get the right bitwise operators, but I soon had a working version in z80 assembly. Below is the original LSFR for moving right. 
 
<pre>; +++
; PITFALL! LFSR - move right!
;       room' = room &amp;lt;&amp;lt; 1 | (bit3 + bit4 + bit5 + bit7)
; input:        d - holds the current room details
; output:       a - holds the new room details
move_right:
        ld a,d          ; load a with room
        sla a           ; could also be add a,a
        xor a,d         ; XOR with room
        sla a
        xor a,d
        sla a
        sla a
        xor a,d
        sla a
        rl d            ; rotate carry into room
        ld a,d          ; and make a the new room
        ret
; end move right
; ---</pre> 
 
The simulator version is a lot more complex as I had to deal with the player being underground. That version uses a loop and has to check for walls. There is also a move left version that reverses the LSFR <a href="https://www.reids4fun.com/za/pitfallsim" target="_blank" rel="noopener">in that code</a>. 
 
Since the LSFR routine alone isn’t very useful, I added a print routine to show what is on each screen. Adding a little bit of logic, based on the rules set forth in the article, I had a working version of the opening sections. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/pitfall-rooms-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="<cite>Pitfall!</cite> Rooms, ZX81 Screenshot of the first 21 rooms, 2023 by Steven Reid"><cite>Pitfall!</cite> Rooms, ZX81 Screenshot of the first 21 rooms, 2023 by Steven Reid</div>
 
 
Sorry if the picture is a bit esoteric. The first is the room value in decimal. Next is the tree pattern. Then, the hazard (i.e. holes, tar pits, crocs, etc.) with wall or treasure (i.e. G is gold). Last is any objects such as logs, snake, or fire. This is the first 21 rooms moving right. And yes, moving left works as well. 
 
# Making Something a Bit More Interesting. 
 
After getting the code working, I wanted to make it something you could actually move through. My intention was not to create a game, but to simply get the look and feel of each room working. I called it a <cite>Pitfall!</cite> Simulator because that is what it is. It simulates the game's screen generations, including the ladders and underground corridors. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/pitfall-sims-2023-zx81-start-screenshot-by-steven-reid-320x240.png" alt="Pitfall! Simulator, ZX81 Screenshot of the Starting Room, 2023 by Steven Reid">Pitfall! Simulator, ZX81 Screenshot of the Starting Room, 2023 by Steven Reid</div>
 
 
It was also at this point that I realized the rules posted in the article were not 100% accurate, as things were not matching up. Digging around, I found <a href="https://meatfighter.com/pitfall/" target="_blank" rel="noopener">a more complete version</a>. Combining those, I soon had a working simulator for <cite>Pitfall!</cite>. The code logic was pretty complex now and I made no effort to optimize it. 
 
To make sure things were working, I used a map link from the original article to verify that the simulator. Funny enough, I found some discrepancies there as well. I ended up finding <a href="https://www.youtube.com/watch?v=pslbO6Fddhw" target="_blank" rel="noopener">actual footage of the rooms</a> to validate the routines. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/pitfall-sims-2023-zx81-crocs-screenshot-by-steven-reid-320x240.png" alt="Pitfall! Simulator, ZX81 Screenshot of the Crocodile Hazard Room, 2023 by Steven Reid">Pitfall! Simulator, ZX81 Screenshot of the Crocodile Hazard Room, 2023 by Steven Reid</div>
 
 
This program is meant as an easy way to traverse the map, but without all the game play. However, if you do go underground, it does block your movement. This makes it easy to test out different paths and see what works. Obviously, the golden path to beat the game in under 20 minutes has long since been discovered. But you might find it fun to try out different paths without a timer or skill getting in the way. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/pitfall-sims-2023-zx81-wrong-way-screenshot-by-steven-reid-320x240.png" alt="Pitfall! Simulator, ZX81 Screenshot of Going the Wrong Way, 2023 by Steven Reid">Pitfall! Simulator, ZX81 Screenshot of Going the Wrong Way, 2023 by Steven Reid</div>
 
 
All that was left at this point was adding in all the visual elements. It was a bit of a chore adding in all the hazards as they tended to overlap other elements. Although the player doesn’t really move in the simulator, I did have to simulate location, specifically which side of the map you are on based on direction of entry. 
 
# Is there more? 
 
Could I have made this into a game? Sure. Will I? Probably not. <cite>Pitfall!</cite> was an iconic game, and trying to convert it to the ZX81 would require so many compromises that it would not be worth it. I would have to significantly reduce the motion and screen size, and even then, trying to achieve a full screen with smooth motion would be difficult. There are games that already emulate it to some extent, and I would not be adding much. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/pitfall-sims-2023-zx81-gold-screenshot-by-steven-reid-320x240.png" alt="Pitfall! Simulator, ZX81 Screenshot of the Gold Loot Room, 2023 by Steven Reid">Pitfall! Simulator, ZX81 Screenshot of the Gold Loot Room, 2023 by Steven Reid</div>
 
 
Instead, I am sharing this for what it is: a realistic <cite>Pitfall!</cite> simulator. It is accurate to the game—perhaps the most accurate so far given what I have seen out there. Additionally, converting the LSFR to the Z80 might inspire others to do something with it. Heck, I might even find a use for it myself.</description>
</item>
<item>
<title>A Trip Down Memory Lane: Recreating “I Was Here” in ZX81 BASIC</title>
<link>https://www.reids4fun.com/554/a-trip-down-memory-lane-recreating-i-was-here-in-zx81-basic</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Sun, 17 Sep 2023 08:39:00 -0600</pubDate>
<category>ZX81 Computer</category>
<category>zx81</category>
<category>retro</category>
<category>basic</category>
<category>monthly</category>
<category>programming</category>
<guid>https://www.reids4fun.com/554/a-trip-down-memory-lane-recreating-i-was-here-in-zx81-basic</guid>
<description><img src="https://www.reids4fun.com/images/zx81/here-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="Here, ZX81 screenshot, 2023 by Steven Reid" style="float:left;margin-right:10px">A recently posted meme reminded me of the silly things we did on computers. In the early eighties, most computers came with BASIC as their default OS. A common starting point was a s simple “hello world” program. But almost as often, someone wrote something a bit more personal. This is <a href="https://www.reids4fun.com/zp/here" target="_blank" rel="noopener">my tribute program</a> to the “I was here” concept of those days.# A retro trip in time.
 
This started with a meme. Humor is often a common bond amongst society and the tech culture isn’t any different. A member of a BASIC group I follow on Facebook posted the meme below. To be honest, it took a minute for me to grasp the full context. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/memberpics/admin/woz_ere_meme.jpg" alt="“Mark woz ere” programming meme.">“Mark woz ere” programming meme.</div>
 
 
For those not familiar with BASIC, the pride the bear feels adding a space is misplaced. It did nothing to the program. In most BASIC dialects, PRINT will add a newline after displaying the text. Thus, what the bears changed is, well, invisible. Think of it as an inside joke. That I got. 
 
What was a bit more obtuse was the whole context. I hadn’t thought about how people would approach computers in the eighties. For many, BASIC or any sort of programming was foreign. To use a computer, you usually bought software. But all these home computers let you write software too. There was an entire cottage industry writing books to help you get the most from your computer. 
 
Of course, getting your most from an 8-bit computer wasn't easy. Besides slower processors and graphics, the BASIC implementation weren't aways the greatest. Memory was also very tight, think kilobytes instead of gigabytes. The world shifts quite a bit with that in mind. This simple meme conjured up the whole idea of digital graffiti for me. Bored kids walking up to computers would type in this simple program. For many consumers, breaking out of the loop would have been a monumental task. These computers were not easy to use.
 
What threw me off was the way the spelling of the words. I could forgive "woz" as slang for “was.” Plus it invoked a bit of the Apple flavor of the time. The “ere” seemed weird though, until it dawned on me. The subtle meaning is that the proud bear should have corrected the spelling. Sigh. Perhaps it being late at night and having spent a day in higher thought finally caused my mind to shut down. 
 
In any case, meme’s aren’t all meant to have singular meanings. They mean what they want to you and if you get something different from it, that’s perfectly okay. 
 
# Taking the less worn path. 
 
Reading through the comments, it reminded me of my childhood. Growing up in the military, I didn’t always have access to shops where computers were out for testing. The PX where were did sell computers, but I rarely saw them running. They were usually IBM clones, expensive and for business. The common home computers weren't there. Instead, they had typewriters of all shapes and sizes. It wasn’t uncommon for me to walk up to them and start typing. 
 
Although on occasion I did put my name in what I typed, it was usually something more akin to a poem or song. “Now is the time for the world to begin again,” and such nonsense. I often do the same today when creating filler text. But the concept, if not the execution, was the same. Unlike the computer graffiti, those words didn’t repeat. 
 
I did have older friends and learned that there were computers at the Junior High. My friend Edmund would share his printouts of pictures with me. After seeing them I would rush home and recreate them on a old typewriter my dad found for me. Hooked on the on the idea of using computers, I couldn’t wait to try them out myself. 
 
That next school year, I did finally get a chance in the 6th grade. My school had an old PDP of some sort with teletype machines connected to them. Not waiting around, I joined the computer club and spent my free time learning BASIC. My programs weren’t great, but they worked. I was able to build pictures that I could save to disk and print out whenever I wanted. It was a start. 
 
# Building something new. 
 
Less than a year later, my Dad bought me a ZX81 computer. I took over the family’s tiny black and white TV so I could program on it. This really got me programming. Yes, some of the first programs were about the same as the meme: simple and boring. Often the first thing you learned on a new computer was how to write “hello world” that would print forever. I had a computer that I could do that with. 
 
Now one of the comments in the group gave an example where he printed the “I was here” in a sine wave pattern. I’d done this a few times in the past on my own ZX81, a common troupe of the era. But it struck me. What if I made it a joke? 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/here-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="Here, ZX81 screenshot, 2023 by Steven Reid">Here, ZX81 screenshot, 2023 by Steven Reid</div>
 
 
Never passing up the opportunity to program, I got to work converting his example into ZX81 BASIC. The code was very straight forward. After some trial and error, I had the guts of the program working. One oddity of the ZX81 is that it doesn’t automatically scroll when you hit the bottom of the screen. Thus, it was the first thing I had to adjust during conversion. The other was to accommodate for the different screen width and BASIC syntax. The concept, otherwise, it is the same. 
 
Except it isn’t. I made <a href="https://www.reids4fun.com/zl/here" target="_blank" rel="noopener">a subtle change to the code</a>. The joke was to change the phrase to “you were here” in the middle of the wave. It was my way of pulling the audience into the program. Read into it what you will. I promptly shared to the group and got a few likes. Worth it. 
 
Could it better, I’m sure of it. But in the end, it was a short and simple program to burn an evening. Enjoy it, or not. I was here.</description>
</item>
<item>
<title>How to Create an Infinite Maze on the ZX81</title>
<link>https://www.reids4fun.com/553/how-to-create-an-infinite-maze-on-the-zx81</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Tue, 22 Aug 2023 23:37:00 -0600</pubDate>
<category>ZX81 Computer</category>
<category>zx81</category>
<category>monthly</category>
<category>retro</category>
<guid>https://www.reids4fun.com/553/how-to-create-an-infinite-maze-on-the-zx81</guid>
<description><img src="https://www.reids4fun.com/images/zx81/infmaze-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="Infinite Maze, ZX81 Screenshot, 2023 by Steven Reid" style="float:left;margin-right:10px">I saw the Commodore 64 maze generator for years, but ignored it on my ZX81 for different reasons. For one, the characters needed didn’t exist on the ZX81 keyboard. The other was the lack of automatic scroll. Undeterred this month, <a href="https://www.reids4fun.com/zp/infmaze" target="_blank" rel="noopener">I created my own version in Sinclair BASIC</a>. I’m quite happy with the results, even if not quite the same.# Not quite 10 PRINT.
 
I’d run across the <a href="https://10print.org" target="_blank" rel="noopener">10 PRINT</a> maze generator some time back. Using unique symbols from the Commodore 64, it forms an endless maze on the screen. To be fair, it works because the screen always has an opening below it, making it more of an infinite runner. But the concept is compact and easy to understand. 
 
[quote=10 PRINT for the Commodore 64 Computer]10 PRINT CHR$(205.5+RND(1)); : GOTO 10[/quote] 
 
The ZX81 has a couple challenges that prevents it from emulating the one-liner. The first, and biggest issue, is that the ZX81 doesn’t support invite scroll. Go to far down on the screen and you get a screen full error. You can use <code>CONT</code> to continue if you like. But that doesn’t follow the spirt of the original program. 
 
The other issue is that the original program is two lines of code. The C64 allows you to concatenate many lines by using the colon separator. I’ve wondered if there was a way around that, but haven’t found a way. Even if I did—as noted above, the characters used by the C64 aren’t available on the ZX81. I have lost my attempt to emulate the simplicity of 10 PRINT. That doesn’t mean I shouldn’t try. 
 
# My infinite maze. 
 
By not using a one-liner concept, there were more options to make something similar. I landed on using the two diagonal block characters (<code>CHR$</code> 6 and 134). There are two ways to print the random characters. The first would be to use the <code>CHR$</code> command along with some math. This takes advantage of the the second character being an inverse of the first. All you need to do is add 128 to it—or not. 
 
<pre>PRINT CHR$ (6+128*INT (RND*2))</pre> 
 
The other way is to use a string slice with the random number selecting an index of the string. This was my first thought and is the <a href="https://www.reids4fun.com/zl/infmaze" target="_blank" rel="noopener">routine I used in the program itself</a>. I think this version is more flexible in that it doesn’t assuming anything about the characters. Thus, you could swap them out with other characters to get different effects. 
 
# Printing and scrolling. 
 
That along didn’t yield the results I wanted as the characters are too compact. This prevents you from using the results as a maze. To compensate, I added single space to the line to give it a bit of breathing room. This works well, but has a side effect of lining up the next line exactly below it. 
 
To make it more maze like, I added in a test to ensure every other line printed a leading space or a trailing one. Those tests created a nice pattern effect, like the C64 version but not exactly the same. 
 
<div class="text-center"><img style="display: block; margin-left: auto; margin-right: auto" src="https://www.reids4fun.com/images/zx81/infmaze-2023-zx81-screenshot-by-steven-reid-320x240.png" alt="Infinite Maze, ZX81 Screenshot, 2023 by Steven Reid">Infinite Maze, ZX81 Screenshot, 2023 by Steven Reid</div>
 
 
To make a never-ending maze, I added the <code>SCROLL</code> command to the program. This moves the display up from the bottom. Using a <code>FOR</code> loop, I controlled the number of characters printed on the line. I then did a <code>NOT</code> on <var>A</var> to adjust the space location and printed the next line. 
 
# Mostly done. 
 
This worked well and generated the maze I was looking for. I like the omit look, even if it took more than a few extra lines of code to work. The screen is quick and creates a random and pretty picture. That said, we could optimize the code further. 
 
Futzing with the routine I found you could drop the <code>AT</code> function by moving <code>SCROLL</code> up. This will use the next line at the bottom of the display. Since I still need the loop, though, It didn’t make a huge difference. It might be a tiny bit faster, but not enough to notice in testing. 
 
[quote=Leonardo da Vinci]Simplicity is the ultimate sophistication.[/quote] 
 
Leaving the program as is, feel free to try to improve it further. Besides minimizing the code, you might also be able to write a 1K version. I’m not sure you could fit a full screen in, but you could get close. There are also hardware and software ways to expand the ZX81 character set to get closer to the C64 version. 
 
For such a simple program, there are many different ways to expand and foster the code. Give it a go and share your successes.</description>
</item>
<item>
<title>Audio.com Review: A New Home for My Music</title>
<link>https://www.reids4fun.com/552/audiocom-review-a-new-home-for-my-music</link>
<dc:creator>Steven Reid</dc:creator>
<pubDate>Sun, 23 Jul 2023 09:54:00 -0600</pubDate>
<category>Music</category>
<category>music</category>
<category>audio</category>
<category>community</category>
<guid>https://www.reids4fun.com/552/audiocom-review-a-new-home-for-my-music</guid>
<description><img src="https://www.reids4fun.com/images/memberpics/admin/vPCB3HLvRyy5ietzVNfW--1--9zxdu.jpg" alt="Picture of Sound Waves, generated with Stable Diffusion, 2023 by Steven Reid" style="float:left;margin-right:10px">It’s been some time since I moved my music over to Myspace after the reboot of Acid Planet. I’ve never been happy with it and have looked for alternatives on and off again. I ran across another offering called Audio.com and decided to <a href="https://audio.com/steven-reid/" target="_blank" rel="noopener">give it a try</a>.# Looking for alternatives.
 
Acid Planet was my first foray into the music community. It was nice as Acid Pro could publish to the platform without any hassles. Besides being a site for free samples, I could also join contests and listen to others offerings. Although still around, I never signed up for the revamped version. It was time to move on. 
 
Given that Myspace had also rebooted around that time, I started there. It was now focused on music and had a slick, if clunky, interface. Overtime it too became stale and never quite worked right in Safari. Plus, all I seemed to get were spam follows. 
 
This led me to continue to look for alternatives. I had been a SoundCloud user for some time, even using it to house some of my ZX81 audio. I liked that you could follow artists and listen to stations. I could share music there but the community wasn’t for me. They pushed subscriptions and, as a long aging hobby, wasn’t where I wanted to spend my time. 
 
# Digging into free alternatives. 
 
Disheartened, I began looking for music players I could integrate into my own site. I found a decent one and built out a test program. Although it worked well, I had a few issues with the playback. It became one of those beats projects I never completed. 
 
So when I ran across Audio.com, it intrigued me. It seems to be community driven, although lacks the forms I liked in Acid Planet. It suggests other creators and has a good search feature. The player is nice and seems to work well in my browser of choice. As a bonus, it integrates with Audacity if I ever get back into editing music. 
 
# Diving in. 
 
Although my choice was to publish using my own player, the look and feel of a third party site is intriguing. Much like I use Flickr to host photos, I want to use Audio in much the same way for songs. I decided to sign up. 
 
Adding songs was pretty straight forward. You drag and drop them into the site and it builds waveforms for them. I had to go searching to find my music I had archived on my Mac mini. Once I had what I wanted, I dragged it there. This is where I ran into some minor issues. 
 
Seems, some of the songs wouldn’t upload. They showed success, but the waveforms weren’t created and I couldn’t listen to the song. After futzing around for a bit, I found you have to be patient with the uploads. I ended up deleting the broken uploads and adding them again. 
 
The next step was to add art work and tags. That worked well and you can share each song or a collection of songs. The sharing feature is actually quite nice. I created a few collections and added songs into them. Then realized I had a problem. The songs were out of order. 
 
Yes, it may not matter to some, but I did want to add them in order of creation. I found an easy fix. Audio members the order that you add a song. To fix the collection, I cleared it and added each song in the correct order. 
 
# Almost done. 
 
With that complete, I now have a new home for my music. You can enjoy my songs from <a href="https://audio.com/steven-reid/collections/eclectic-vibes" target="_blank" rel="noopener">elective Vibes</a> or wacky video music from <a href="https://audio.com/steven-reid/collections/fly-me-to-the-moon" target="_blank" rel="noopener">“Fly me to the moon.”</a> These are the same tracks I shared on Myspace and will be updating links to the new site as I find them. 
 
<iframe src="https://audio.com/embed/collection/1772150151033320?theme=image" style="border-radius: 6px; border: none; height: 204px; width: 204px;"></iframe></description>
</item>
</channel>
</rss>

If you would like to create a banner that links to this page (i.e. this validation result), do the following:

Download the "valid RSS" banner.
Upload the image to your own server. (This step is important. Please do not link directly to the image on this server.)
Add this HTML to your page (change the image src attribute if necessary):

<a href="http://www.feedvalidator.org/check.cgi?url=http%3A//feeds.feedburner.com/ReidsForFun"><img src="valid-rss-rogers.png" alt="[Valid RSS]" title="Validate my RSS feed" /></a>

If you would like to create a text link instead, here is the URL you can use:

http://www.feedvalidator.org/check.cgi?url=http%3A//feeds.feedburner.com/ReidsForFun

Home · About · News · Docs · Terms