atariaction

[atariaction]

Kay’s 2023 Wrapped

Well, that about wraps it up for 2023, which means it’s time for my letter summarizing the computer history work that I did in the past year. I’ve been writing these letters since 2016, making this my eighth annual letter. I wish I had started this tradition in 1996, the year that my computer history efforts began when I launched the Digital Antic Project, which grew into Classic Computer Magazine Archive.

My goal this year was to publish six interviews on Antic: The Atari 8-Bit Podcast. I published just one. (It was a good one, with Rodrigo Castro about Atari in Chile. Why not six? My Internet Archive work and, simply, a lack of momentum on interviews. Once the process is going, it’s going! But getting that engine re-started is hard.) My goal for 2024 is to publish 15 interviews, which I fully expect to actually do. Between us over the years, Randy Kindig and I have published 436 interview episodes on Antic. Our collective goal is to reach 500 by the end of 2025. So to keep my end of the bargain, that means I’ll publish 15 interviews in 2024.

Scanning, though! I turned all sorts of rare paper material into easily-searchable digital material at Internet Archive. I scanned a lot of Atari newsletters, including many from Hughes El Segundo Employees Association Atari Computer Enthusiasts, South Bay Atari Computer Enthusiasts, and West LA Atari Users Group.

In other scanning news — let’s talk about MicroTimes. MicroTimes was a California-focused computer magazine that was published from 1984 through 1999. It was there in the thick of it, published in the state that brought us Silicon Valley. I wrote for MicroTimes for a few years starting in 1992. So I am especially proud of this: 41 issues of MicroTimes magazinewere added to Internet Archive in 2023, bringing the collection to 62 issues. Here’s the long-story-short summary of 10 years of effort: I made this happen. I willed it to happen. More issues will be added in 2024.

I also added two more books to the collection of Russ Walter’s Secret Guide To Computers at Internet Archive. The newest additions are hard-to-find editions from 1976, about BASIC programming and computer applications.

My Scantastix project (if you don’t know what that is, here’s a short article describing it) did some great work: we scanned 321 items totaling 22,577 pages. The scans include some rare Microsoft material, even rarer pamphlets and manuals for Compucorp computers (have you ever heard of them? The computer that came with them is on its way to Vintage Computer Federation) and so many Apple II manuals. Check out all the latest additions here.

Also, a weird scanning side-quest happened this year: My friend Cabel Sasser handed me a pile of more than 50 DAK catalogs, which I scanned for him, then he wrote a blog post about them that blew up the Internet for a few days. It’s a fun read.

Once again, I processed and edited videos of the presentations at Vintage Computer Festival West 2023and VCF East 2023. And I helmed a project to rescue audio from VCF West 2003. These were recordings that were made of talks twenty years ago, then the tapes were lost, then found, then given to me, then it turned out that the tapes were recorded terribly. It took a small team of people to get any sound at all from those tapes then turned into something listenable. They include the voices of C. H. Ting, Jef Raskin, John Ellenby, and Gary Starkweather, who have all passed since these were recorded.

When I interview a programmer, I ask the person if they have any source code. I interviewed Jay Jaeger, creator of the Atari Program Exchange version of Space War, in 2016. At the time he said he had the source code… somewhere. I contacted him from time to time to ask about that source code. (I have a “nag list” of people that I contact from time to time to ask them about some material or other.) Patience and persistence paid off. Just a few days ago, in December 2023, he found the assembly language source code and sent it to me to share.

A bit of personal archiving: I write for Juiced.GS magazine, which focuses on the Apple II. I uploaded all of the articles I've written for Juiced to Internet Archive, spanning 2015–2022. There are some interviews, some product reviews, and some nice little reminisces about the old days of microcomputers. (I released them under a Creative Commons license, so if you want to republish an article in a non-commercial computer club newsletter or something like that, go for it. My agreement with the magazine says that they get exclusive rights to articles for a year. So my 2023 articles will be shared online a year from now. In the mean time, it’s a good magazine: if you like Apple II, subscribe!)

My work at Internet Archive as the curator of the Digital Library of Amateur Radio & Communications is certainly one of the reasons I’ve had less time and energy for computer archiving. 2023 was my first full calendar year in this role. I hit my one-year anniversary in August! But there’s sometimes a nice overlap between the two efforts. For instance, in 2023 I archived several ham radio related programs for Atari computers and a few for DOS machines and even a handful for CP/M that were rescued from 8-inch floppy disks.

There’s something else, something that I’ve been teasing for years. In my 2018 letter I wrote “There’s a particular archiving project happening in 2019 that is really big and really important for microcomputer history. I’m not ready to talk about it, but hold your breath and cross your fingers.” Then at the end of 2019 I wrote: “That project depends on the help of one person who has been battling ongoing health issues. It is still very much at the front of my mind, and *crosses fingers* will move ahead this year.” It didn’t, and it couldn’t, but with patience and persistence, it’s finally happening. It’s already started, and I can’t wait to have something amazing to show you in 2024. Keep holding your breath and crossing your fingers just a little while longer.

If you support my archiving work on Patreon, thank you! Also please consider making a tax-deductible donation to Internet Archive, the non-profit online library that hosts all of my scans and interviews.

I hope we all have a pleasant and productive 2024. May your patience and persistence pay dividends.

#atari #interviews #computerhistory #internetarchive

[atariaction]

Kay’s 2022 Wrap-Up

Greetings from the tail end of 2022. This is my annual letter summarizing the computer history work that I did this year.

When I wrote last year’s letter, I was in a bit of a funk. I wrote:

I doubt I will be as productive in 2022 as I was in 2021 … I can’t predict how much energy I will have to devote to these projects in 2022. I need a break from so many interviews (each is more time-consuming than you might guess), and spending hours processing piles of scanned documents does not appeal to me at the moment.

In retrospect, I was right — I produced less in 2022 than 2021, and I really did need a break from interviews and so much scanning. But 2022 ended up being a fairly successful year for my computer history efforts, some of it in ways other than interviews and scanning. 2023 promises to be at least as productive.

I published just four interviews on ANTIC: The Atari 8-Bit Podcast. There was Tom Zimmerman, who worked in in Atari's Corporate Research Lab on the unfinished AMY audio chip; Anthony Ramos, creator of the type-in game Creepy Caverns and the software for the Parrot audio digitizer; Michael Park, programmer of the Swan and Fujiboink demos; and Scott Savage, who built “Lefty,” a robot that played checkers. All four people gave great interviews!

I’ll certainly continue doing interviews in 2023. I don’t want to sound like I’m making excuses, but I will say that with 400+ interviews in the bag, finding people to interview is much harder than it used to be. The people who were findable have been found; the people who were agreeable to an interview have been interviewed. There are still more stories to be told, but the path only gets steeper. Let’s shoot for at least six interviews in 2023. 

I did some solid software preservation work in 2022. With the help of 4am and John Keoni Morris, we preserved the only known copy of Glutton, an unreleased game for the Apple II. 

I digitized the entire library of the Ol' Hacker's Atari User Group over a period of two months and made them available at Internet Archive. That collection weighs in at 1,281 .atr files, or 130 megabytes! My thanks to John Hardie at the National Videogame Museum for lending me that collection. You can find discussion of that collection in the AtariAge forums.

The scanners got a bit of a workout in 2022 as well. I scanned the complete run of ITEC (Information Technology Electronics Computers), a partwork magazine published by GEJ Publishing Ltd. in the United Kingdom from 1983–1984, as well as 11 issues of AppleLink Update magazine. I also found a cheaper way to scan large-format posters, which I used to make hi-res scans of a 1989 Ukraine Computer Exhibition poster and the 1984 Atari Final Legacy poster.

The rest of my output, I can only lump into an overarching category I’ll call Miscellaneous Computer History Preservation:

My pal in the Atari 8-bit world, Sal Esquivel, died in December. I did what I could to preserve his memory by archiving his YouTube videos into a collection at Internet Archive. I’m working with Allan Bushman to create a complete collection of Atari Program Exchange manuals and catalogs at Internet Archive. I put several of the Phoenix Software source codes (preserved by me years ago) up at GitHub for easier access: Adventure in Time, Queen of Phobos, and Birth of the Phoenix.

I edited the videos of the all the presentations at Vintage Computer Festival East 2022 and VCF West 2022, and made them available at YouTube and Internet Archive.

Having finished scanning every issue of Mid-Michigan Atari Magazine and Michigan Atari Magazine, I created a “complete collection” 1000+ page PDF which is either a) very handy or b) will hopelessly choke your PDF viewer.

Russ Walter has been writing and updating Secret Guide to Computers (later renamed Secret Guide to Computers & Tricky Living) since 1972. Currently in its 34th edition, Mr. Walter has kept the book updated as hardware, software, and operating systems have evolved. I worked with him to get as many editions as possible preserved and free to download from Internet Archive. Thanks to the Kahle/Austin Foundation for funding the scanning of those books.

A surprise came late in 2022 when I was offered a role at Internet Archive — it turns out that my years and years of preserving computer history taught me a few things, so now I am Internet Archive's Program Manager, Special Collections. My role is to curate the Digital Library of Amateur Radio & Communications. I’m having a great time doing that work. It’s the same sort of work as computer history, in a slightly different, but just as nerdy, field. It takes away from the time I can devote to computer history preservation, but it’s a change that I needed.

But! I’m excited for computer history projects in 2023! Having found the guy who wrote the line “Have you played Atari today?” I plan to publish an article or print interview about him and that famous tagline. I’ll continue filling out the Atari Program Exchange collection at Internet Archive. There are a lot of Apple II and Atari documents in a pile to get online for the Scantastix project. And, as I wrote above, I’ll shoot for six interviews. 

Here’s to a productive and fun 2023. Let’s do this.

-Kay

P.S. Like many others in 2022, I moved from Twitter to Mastodon. You can follow me at @[email protected].

[atariaction]

Kay’s 2021 Wrap-Up

It’s the waning days of 2021, which means it’s time for my annual summary of the computer history efforts I’ve made in the past year.

I published interviews with 29 people across 28 episodes of ANTIC: The Atari 8-Bit Podcast. Many of those interviews can be grouped into specific subjects that I gave extended attention to. Those subjects were:

The Capital Children’s Museum and Interactive Picture Systems. The museum was home to a large lab of Atari (and later, Apple) computers, as well as the office of Interactive Picture Systems and the “Superboots” software development lab.

Atari Research. I did five interviews with people who worked in Atari’s famed R&D lab.

Atari computers at the science fair. I interviewed three people who, as kids, used their Atari computers for school science fair projects.

Computers: Expressway to Tomorrow — a deep dive into a multimedia school assembly, sponsored by Atari, that was seen by more than a million middle- and high-school students in 1983 and 1984.

Some of the folks that I interviewed still had old source code, which they gave to me and allowed me to share with you. I unearthed the Forth code for Worms? by David Maynard as well as his development notes; three published and two unpublished programs by Ed Fries; and LOTS of Apple II Forth source code — both published programs and their development tools — from Prentice Associates.

In a collaboration with programmer Peter Liepa, I preserved the source code to several versions of Boulder Dash, but I am not able to share them due to German copyright law. (A German company owns the rights to Boulder Dash and still publishes new versions.) Still, it’s good to know that the code won’t be lost.

The media I digitized wasn’t limited to code. Filmmaker Lucy Hilmer generously gave me a U-Matic videotape of The Magic Room, Atari’s 1983 documentary about Atari computer camps, which I had professionally digitized, as well as a folder of production documents related to the film. After digitizing them, I donated all the material to The Strong Museum of Play.

After my interview with Suzanne Ciani, she found an unpublished song that she produced for Atari and allowed me to share it. “My Atari” is a bop.

I also unearthed Brenda Laurel’s Atari research memos on the subject of interactive fantasy, which she didn’t have anymore but were buried deep on a very old, very janky hacker site.

I scanned a figurative ton of material in 2021, even purchasing an A3-sized bookedge scanner for larger-format material. I scanned 83 issues of Home Computer Advanced Course magazine, completing the Internet Archive’s collection of that fun UK publication. I also scanned dozens of Atari newsletters, including issues from Jersey Atari Computer Group, Atari Interface, South Shore Atari Group, Atari Times, Bay Area Atari Users Group, Atari Computer Enthusiasts, and Atari Dealer News. (In a herculean effort to organize my workspace, I donated these newsletters to The Strong also.)

Dan Kramer sent me amazing batches of material to scan. Dan, who worked at Atari from 1980 to 1984 in the consumer engineering group, created the Trak-Ball accessories for the Atari game consoles and computers. He also worked on the prototype Atari 2700 and various other projects. I scanned his Atari engineering notebook as well as the schematics and notes that he had saved regarding the Atari Cosmos, an unreleased holographic tabletop game; the Atari 2700 with radio-controlled joysticks; SECAM video versions of the Atari XL computers; and more.

I continued work on the Scantastix project, adding 310 items (primarily Apple II manuals provided by 4AM.) Those 310 items totaled at least 8,000 pages. I lost count.

Other projects that I completed in 2021:

Copying my back catalog of 450+ audio interviews onto YouTube to increase their visibility and reach.

Creating The Internet Archive Research Assistant (TIARA), a tool for researchers who use Internet Archive.

Processing videos of the presentations at Vintage Computer Festival West and VCF East 2021.

Looking ahead: to be perfectly honest, I doubt I will be as productive in 2022 as I was in 2021. The end of December, and the end of 2021 in particular, probably isn’t the best time for me to write this summary. The short winter days weigh on me. I am healthy, but the lingering effects of wave after wave of covid are draining me emotionally. I can’t predict how much energy I will have to devote to these projects in 2022. I need a break from so many interviews (each is more time-consuming than you might guess), and spending hours processing piles of scanned documents does not appeal to me at the moment. It’s possible that a bunch of exciting new projects will reveal themselves this year, and it’s possible I’ll regain the energy and emotional bandwidth to dive into them. It’s also possible that 2022 will be a quieter year. So I’m making no predictions, setting no goals. I’m going to take things a little bit at a time and see where 2022 takes me.

Thanks to my supporters for joining me on this journey, whatever waves and crests it endures.

-Kay Savetz, December 26, 2021.

#atari #computerhistory #interviews #yearend #2021

[atariaction]

2020 Post-Mortem

It's 2021. Thank goodness. I don't need to tell you that 2020 was a horrendous year. I’m just glad that it's over. Of course, the flipping of the calendar doesn't change a thing, but the new year brings hope that the days to come will be better than the days behind us. The flipping of the calendar won't bring back the 1,800,000+ people worldwide who have died of COVID-19. It won't bring back my friend and fellow Atari historian Curt Vendel, who also died last year. It won't bring back all the hair that I lost due to stress.

But if the flipping of the calendar to a new year is a symbol of hope and renewal, I'll take it. With vaccines being administered and a fascist regime on its way out the door in my country, I am hopeful for 2021.

This is the annual post where I make a summary and self-inventory of the computer history work that I did over the previous year. I set a goal in January before the pandemic hit... and I met the goal despite it. For me, thinking about interviews and scans and archiving is often a welcome distraction from the news and the sadness and the stress. I was lucky. Unlike so many others, my work was steady, my health was great, and my family was safe.If you didn't get the stuff done that you wanted to do last year, don't worry about it.

If you didn't accomplish anything other than just muddling through: Don't. Worry. About. It. You made it through. We made it through. 2021 will be better.

So. My goal for 2020 was to publish at least 20 interviews on ANTIC: The Atari 8-bit Podcast. I met that goal. By the end of the year, I published 31 interviews across 26 episodes.

I got to delve into aspects of computer history that hadn't been explored before, such as the short-lived radio show The Famous Computer Cafe; and Sofcast, a different radio program that transmitted software over the airwaves. In non-radio-related interviews, I talked with Brad Stewart, the founder of Covox; and Mark Barton, the creator of Software Automatic Mouth. In non-voice-synthesis-related interviews, I talked with the creators of Atari Speed Reading and the Atari Conversational Language series. In non-obscure-educational-software-related interviews, I interviewed famous musician Suzanne Ciani, who produced commercials and soundscapes for Atari.

It was, I hope, important work that unearthed stories and information that was not available before. My goal for 2021 is to interview at least another 20 people.

In 2019, I announced Scantastix, a highly-curated set of scanning projects meant to fast-track documents into digital form at Internet Archive. At the end of 2019, we had scanned 4,900 pages of material comprising 83 items. By the end of 2020, the totals were 48,791 pages comprising 653 items, an increase of 43,891 pages and 570 items (!) including many VAX/VMS manuals, Apple II manuals, and Apple, Mac, and Atari newsletters and magazines. This effort is not inexpensive (I hire people to do the scanning) and accepts contributions separate from my Patreon.

In other scanning news, Carol Shaw sent me her source code printouts of Colleen Calculator (an early 9K version) and Atari VCS Checkers rev. A. I scanned them, then members of the Atari community got them digitized and compile-able. At Carol's request, the original printouts are now stored at the Strong Museum of Play in Rochester, New York. Hillel Segal sent me 254 computer columns that he wrote for the Denver Post from April 1985 through May 1990, which I helped get into Internet Archive.

Also, I processed the videos created for the (virtual) Vintage Computer Festival West 2020 and VCF East 2020 shows, and uploaded them to Internet Archive and YouTube.

In playtime news, I created @Atari8BitBot and @AppleIIBot, two bots you can use to run code on 8-bit computers right in Twitter. My buddy Carrington and I finished playing all the Infocom text adventures for our Eaten By A Grue podcast. We're now moving on to Infocom's smattering of graphical adventure games.

I have no news to report on my book about Atari dissertations, updates to Jumpman, or the secret special archiving project. Maybe this year.

Let out a collective breath with me. Here’s to a healthy and productive 2021.

-Kay Savetz, Jan 1 2021.

#atari #computer history #apple II #interviews #2020

[atariaction]

10-Line Blackjack

Hot on the heels of the poker game, I wrote a blackjack game for the 10-line BASIC contest. It is also in TurboBASIC XL on the Atari 8-bit, and also in ten 120-character lines. I borrowed the card shuffling code from the poker game, but otherwise it’s all new code.

As always with these short programs, there were some space tradeoffs. In exchange for a wallet/calculating money, I found room to show simple card graphics. I also had to give up the custom character with the cute little “10” character. Instead, “T” represents the 10 card.

Like standard blackjack, it starts by dealing your two cards face up, one dealer card face up and one face down. You can press H to hit (take another card) or S to stand (stop taking cards.) (This version does not support doubling down or splitting hands.) After you Stand, it reveals the dealer’s face-down card and the dealer plays. The dealer follows standard Las Vegas rules: always hitting on 16 or less; always standing on 17 or more.

The biggest challenge was calculating Aces, which in Blackjack can count for either 1 or 11. When figuring the player’s score, it starts by assuming an Ace is worth 1. When the player Stands: if the player holds an ace and counting it as 11 won’t cause the player’s total to exceed 21, it adds 10 to the player’s total. On the other hand, when calculating the dealer’s score, it starts by assuming an Ace is worth 11. If after a hit the dealer’s total exceeds 21 and it holds an Ace, it reduces the dealer’s total by 10 and keeps on playing.

Here’s the code:

REM BLACKJACK - KEVIN SAVETZ - JAN 2-3 2020 DIM CARDT$(15),CARDM$(15),CARDS$(15),CARDD$(15),CARDE$(15),SUIT$(4),N$(13),U(52),D(14),NUMCARDS(1),SUM(1),V$(13),I$(1),ACES(1) GR.0 POKE 82,0 CARDT$="\11\12\12\12\12\12\05\1E\1E\1E\1E\1E\1E\1E\1D" CARDM$="\7C \7C\1E\1E\1E\1E\1E\1E\1E\1D" 'CARDT$: card top 'CARDM$: card middle 'CARDS$: card middle with suit 'CARDD$: card middle with number in upper left 'CARDE$: card middle with number in lower right 'Card bottom and card back are drawn in the GOSUB area without strings to save space here 'U: Temp. storage whether a card has been placed in the deck 'D: Deck of randomized cards 'NUMCARDS: Number of Cards held by player/dealer 'SUM: SUm of player and dealer cards 'I$: storage for INKEY$ keyboard input 'ACES: Number of ACes held by player/dealer that may be counted at the other value (1/11) N$="A23456789TJQK":'one-character card names. V$="\01\02\03\04\05\06\07\08\09\0A\0A\0A\0A":'values of cards A-K SUIT$="\00\10\60\7B":'heart club diamond spade 'SHUFFLE FOR X=0 TO 14:'Fill slots. Only slotting 15 cards is faster than 52. N=0 WHILE N=0:'while we haven't found a card for this slot Y=RAND(52):'which card might go in this slot? IF (U(Y)=0):'if we haven't slotted this card yet D(X)=Y:'slot now contains this card U(Y)=1:'mark card as used in a slot N=1:'move on to next card ENDIF WEND NEXT X 'Deal cards FOR HAND=0 TO 1 FOR P=0 TO 1 OB=HAND AND P:'if second card going to dealer, show card back (OBscure it) GOSUB 50 NEXT P NEXT HAND 'Ask Hit or Stand WHILE I$<>"S" AND SUM(0)<22 I$="" ?"\1D\C8it/\D3tand?"; WHILE I$<>"S" AND I$<>"H" I$=INKEY$ WEND ?"\9C":'erase old Hit/Stand query IF(I$="H") P=0:'the player is getting cards GOSUB 50 ENDIF WEND 'After player has played, while player holds an ace, and if 11 is better for the 'score than 1, add 10 to the SUm total. WHILE ACES(0) AND SUM(0)+10<22 ACES(0)=ACES(0)-1 SUM(0)=SUM(0)+10 WEND P=1:'Now dealer's turn GOSUB 50:'reveal SEcret OBscubed card IF ((SUM(0)=21 AND NUMCARDS(0)=2)=0):'Skip next part if player got blackjack WHILE (SUM(0)<22 AND SUM(1)<17):'if player hasn't busted and dealer's hand <=16 PAUSE 60 GOSUB 50 'If >21 but dealer holds an ACe, change value of that ace from 11 to 1 WHILE SUM(1)>21 AND ACES(1) ACES(1)=ACES(1)-1 SUM(1)=SUM(1)-10 WEND WEND ENDIF 'Display totals and winner POS.0,22 ?"You: ";SUM(0);"\7F\7FDealer: ";SUM(1) 'reusing CARDT$ for the summary text CARDT$="Push" IF SUM(0)<22 IF SUM(1)>21 OR SUM(1)<SUM(0) CARDT$="You win!" ENDIF IF SUM(1)<22 AND SUM(1)>SUM(0) CARDT$="Dealer wins" ENDIF ELSE CARDT$="Busted" ENDIF ?CARDT$; WHILE INKEY$="":WEND RUN 50 CARDS$=CARDM$:CARDD$=CARDM$:CARDE$=CARDM$ POS. NUMCARDS(P)*2+P*20,2+NUMCARDS(P)*2 IF (P=1 AND SE):'reveal the SEcret card X=SE-1 SE=0 ELSE X=D(Z):'otherwise, next card in the deck Z=Z+1:'set pointer to next card ENDIF N=X MOD 13+1:M=X DIV 13+1 ?CARDT$;:'card top IF (OB=0):'if not OBscuring card... CARDS$(4,4)=SUIT$(M,M):'put suit on card middle CARDD$(2,2)=N$(N,N):'put number on upper-right CARDE$(6,6)=N$(N,N):'and lower-left ?CARDD$;CARDM$;CARDM$;CARDS$;CARDM$;CARDM$;CARDE$; SUM(P)=SUM(P)+ASC(V$(N,N)):'add to player's SUm total IF card face is shown SUM(P)=SUM(P)+(10*P*(N=1)):'When dealer draws an ace, count it as 11 NUMCARDS(P)=NUMCARDS(P)+1:'increment Number of Cards held by player ACES(P)=ACES(P)+(N=1):'numbr of ACes held by that player ELSE:'OBscuring card FOR X=1 TO 7:?"\7C.....\7C\1E\1E\1E\1E\1E\1E\1E\1D";:NEXT X:'back of card pattern SE=N:'save SEcret card OB=0:'don't OBscure next card ENDIF ?"\1A\12\12\12\12\12\03":'card bottom RETURN

#TurboBASIC XL #Atari #Blackjack #BASIC #Atari 8-bit

[atariaction]

10-Line Poker Machine

My first entry for the 2020 10-line BASIC contest is a poker machine simulator written in TurboBASIC XL for the Atari 8-bit computer. At ten 120-character lines, it qualifies for the PUR-120 category. It is based on the common “Jacks Or Better” poker machine, although I changed the payouts to make it more fun and to conserve space.

The game deals a hand of five playing cards. You can choose to “hold” any or all of the cards by pressing 1 though 5, then press any other key to replace the cards that you did not hold. (Held cards are not replaced.) It then calculates whether you’ve won, based on standard poker hands.

Here are the payouts:

royal flush +650 (real game: 1250) royal straight +500 (not in real game) straight flush +350 (real game: 250) 4 of a kind +225 (real game: 125) full house +150 (real game: 30) flush +150 (real game: 25) straight +200 (real game: 20) 3 of a kind +150 (real game: 15) 2 pair +50 (real game: 10) pair of Jacks or better +5 (real game: 10)

With all the logic for calculating poker hands, there wasn’t room for card graphics. I did make a custom character set with just one special character: a "10" for the only two-digit card. I am proud of squeezing in money though. You start with $50 in your wallet, and the game costs $5 per hand. The game remembers your wallet by poking it into unused memory ($600, the top of Page 6) then peeking it back after it re-RUNs. Because RUN clears all the variables, this uses much less program space than resetting all the variables by hand.

Here’s the code:

GR.0:POKE 752,1:REM SET UP SCREEN DIM D(9),U(53),C(13),W$(29),I$(1),H(5),F$(8),SUIT$(4),N$(13) F$="\00\CE\DB\DB\DB\DB\CE\00" B=DPEEK($600)-5:'money. minus 5 builds in the cost of the round. B=B+(45*(B<0)):'that is, IF(B<0) THEN B=50-5. 'Since there's not enough space to zero-out necessary variables if 'we were to loop to play again, and we lose all variables at re-RUN: 'we save user's money in page 6 where it's safe from BASIC. 'On first run, cross our fingers that $600 is seeded 'at 0, otherwise \_(ツ)_/ ?"$";B:? REM D - cards in shuffled order. This game only deals max 10 cards REM U - tracks whether card number in subscript has been shuffled in REM C - Counts number of each card in suit REM W$ - Win/loss text REM I$ - storage for INKEY$ REM H - tracks which of the 5 card slots are Held REM F$ - custom character ("10") REM SUIT$ - control characters for suits REM N$(13) - card name characters (A thru K) SUIT$="\00\10\60\7B":'heart club diamond spade N$="A23456789#JQK":'one-character card names. '10' replaces # 'Replace '#' with "10" character CH=(PEEK(106)-16)*256:MOVE 57344,CH,1024 MOVE ADR(F$),CH+24,8:POKE 756,CH/256 'SHUFFLE FOR X=0 TO 9:'Fill slots. Only slotting 10 cards is faster than 52. N=0 WHILE N=0:'while we haven't found a card for this slot NN=RAND(52):'which card might go in this slot? IF (U(NN)=0):'if we haven't slotted this card yet D(X)=NN:'slot now contains this card U(NN)=1:'mark card as used in a slot N=1:'move on to next card ENDIF WEND NEXT X REM FORCE CARDS FOR TESTING 'D(0)=12 'D(1)=12+13 'D(2)=13+6 'D(3)=13+13+6 'D(4)=15 FOR GO=1 TO 2:'Do the next part twice 'SHOW CARDS FOR X=0 TO 4 'Show card name, suit, and the slot number N=D(X) MOD 13+1:M=D(X) DIV 13+1:?N$(N,N);SUIT$(M,M);" \1B\7F";X+1 'D(X) MOD 13+1 is the card number 1-13 'D(X) DIV 13+1 is the suit 1-4 'This is very clever. NEXT X IF(GO=1):'Choose hold cards, first time though only WHILE QQ=0 POKE 764,255 WHILE I$="" I$=INKEY$ WEND POKE 764,255:I$="" I=ASC(I$)-49 IF(I>=0 AND I<5) H(I)=NOT H(I):'Toggle hold status for chosen slot POS.9,I+2 IF(H(I)):?"HOLD":ELSE:?" ":ENDIF ELSE QQ=1 ENDIF WEND 'Replace cards that were not held. 'Every card has one potential replacement FOR X=0 TO 4 D(X)=D(X+5*(1-H(X))) 'if held, D(X)=D(X), unchanged. if not, D(X)=D(X)+5 'or, more readably: IF(H(X)=0):D(X)=D(X+5):ENDIF NEXT X ENDIF POS.2,8*GO:'Show new cards under old cards NEXT GO 'Game is over, now see if it's a wining hand 'Count each card type in the hand F=(D(0) DIV 13)+1:'F="is there a flush?" seed with 0th card suit FOR X=0 TO 4 N=D(X) MOD 13 C(N)=C(N)+1:'C(N) is how many of that card in the hand 'T is the maximum number of similar cards we've found T=T+(C(N)-T)*(C(N)>T) 'or, more readably: IF (C(N)>T):T=C(N):ENDIF F=((D(X) DIV 13)+1=F)*F:'if suit is not the same, set F to 0. I feel clever. NEXT X 'Count pairs - how many sets of exactly 2 are in the hand? FOR X=0 TO 12 P=P+(C(X)=2) 'Or, IF (C(X)=2):P=P+1:ENDIF NEXT X 'FULL HOUSE OR 3 OF A KIND OR 4 OF A KIND IF T>2:'really this is: IF T=3 OR T=4 becasue it can't be more IF P:'If there's also a pair W$="FULL HOUSE" B=B+150 ELSE W$=STR$(T) W$(2)=" OF A KIND":'msg is 3 or 4 of a kind B=B+(T-1)*75 ENDIF ELSE:'max same cards T <= 2 IF ((C(10)=2) OR (C(11)=2) OR (C(12)=2) OR (C(0)=2)) W$="JACKS OR BETTER" B=B+5 ENDIF IF(P=2) W$="2 PAIR" B=B+50 ENDIF ENDIF C(13)=C(0):'Kludge to copy Ace to above King FOR X=0 TO 9 IF (C(X) AND C(X+1) AND C(X+2) AND C(X+3) AND C(X+4)) W$="STRAIGHT " B=B+200 IF (X=9) W$="ROYAL " B=B+250 ENDIF ENDIF NEXT X 'Print win/loss message IF(W$="" AND F=0) ?"LOSE"; ELSE ?W$; IF F ?"FLUSH"; B=B+150 ENDIF ENDIF ?:?"$";B DPOKE $600,B 'Save $ on page 6 for next round 'WAIT FOR KEYPRESS, PLAY AGAIN WHILE INKEY$="":WEND RUN

#BASIC #TurboBASIC XL #Poker #Poker Machine #atari #programming

[atariaction]

2019 Post-Mortem

Hello, it’s 2020, and time for my annual look back at the computer history work that I did in the past year. I find it helpful to make a periodic checkpoint, and the start of the new year is a good time to do it.

The bulk of the year’s work happened at the scanner. I scanned a massive amount of computer history documents and uploaded them to Internet Archive. This material included source code: the source code Leafer Madness, an unfinished game for Atari 8-bit computers (along with its development notebook); Atari Karateka Development Disks; and the Daisy Dot II printing application.

I scanned 24 issues of Semaphore Signal, an Apple Lisa/Macintosh publication that was published from June 17, 1983 through May 31, 1985; and 37 issues of Pragma and Pragma's Product Profiles, two publications devoted to the Pick Operating System. (The remaining issues of those three publications are in a larger format that requires a different scanner. I’ve already started on these in 2020 so the online collections will be complete.) I scanned Auerbach Microworld volume 1 and volume 2, a behemoth 1986 index of computer applications, systems software, microcomputers, and peripherals. The most popular single item that scanned was the beautiful Fall 1989 NeXT Software and Peripherals catalog.

I discovered and scanned several new old dissertations and theses involving 8-bit computers, including Transversion System - An Apple II to Commodore 64 File Transfer/Conversion System, Assembly Language Debugging Hardware/Software For The Commodore 64 Computer, and Microcomputer I/O For A Real Time Automatic Equalizer using a Commodore 64. (My mini-book summarizing 20 Atari computer-related theses stalled completely in 2019. I hope to finish it in 2020.)

Other unique finds that I scanned included the 1984 Atari Telephone Directory, the Atari Office Supply Catalog and Office Administration Handbook, and Atari 800 - send your student to school with a secret weapon, a rare catalog of educational software for the Atari 800 computer.

It’s one thing for me to find and scan computer history things, but what if we could create an organization to create a repeatable, fundable process to scan tech history material and get them into Internet Archive? That’s what Jason Scott and I are doing with a new project called Scantastix. Scantastix is a highly-curated set of scanning projects meant to fast-track documents into digital form at Internet Archive. It is crowd-funded. Soon after launching the project in 2018, the Scantastix project scanned and uploaded 4900 pages of material (comprising 83 items, including many rare Apple II software manuals.)

In 2019 I mostly took a break from from doing interviews for the Antic podcast. I was feeling burned out, not enjoying the process as much as I used to. As a result, I published seven interviews on the podcast. Most of those came at the end of the year as I was emerging from a self-imposed break. I’m looking forward to getting back to interviews in 2020. I am keenly aware that the people I want to interview are getting older — and with that comes forgetting things, health problems, and dying. I need to get back to these interviews while there is still time. My goal for 2020 is to publish at least 20 interviews.

In addition to the podcast interviews, I got to interview Steve Meretsky about interactive fiction at GitHub headquarters, and participate in a panel at Portland Retro Gaming Expo, titled “Atari 800 series computers: 40 years” with Joe Decuir and David Crane! I was thrilled to be able to participate in both events. I was also invited to write a blog post for Internet Archive highlighting some of the Atari computer history resources that I’ve uploaded over the years — sharing these resources with people who might not be aware of the tech history trove that is Internet Archive.

Last year I wrote about a “particular archiving project...that is really big and really important for microcomputer history.” That project depends on the help of one person who has been battling ongoing health issues. It is still very much at the front of my mind, and *crosses fingers* will move ahead this year.

(Oh, and I’m continuing to play all of Infocom’s text adventures with @Carrington for the Eaten By A Grue podcast (10 games left to go!) The project with Rob McMullen to add new levels to Jumpman has been waiting for him to upgrade his Omnivore project. It should also see progress in 2020.)

I’m looking forward to a productive 2020. Let’s do this thing!

[atariaction]

Garden: BASIC Tenliners Contest 2019 entry

A quickie, final entry for the 2019 10-liner BASIC contest: GARDEN.

Inspired by arjanvandermeij's #plottertwitter art "8 bits binary flowers," I wanted to create something similar on the Atari 8-bit. I recently learned how to draw ellipses in my work on Renderiffic, my SVG renderer for Atari 8-bit computers, and learned how to rotate shapes from Bruce Artwick’s book Microcomputer Displays, Graphics and Animation. It was easy to combine the two techniques to draw a garden of elliptical flowers.

The program is just a little screensaver that endlessly draws and erases flowers. It’s not a game, so qualifies for the WILD category of the 10-line contest. It’s only four, 120-character lines in Turbo-BASIC XL. Once I get my 1020 plotter back from the fixit guy, I’ll make a version that draws these shapes on paper.

'inspired by @arjanvandermeij's "8 bits binary flowers" 'https://twitter.com/arjanvandermeij/status/1108485237296762880 GRAPHICS 8+16:POKE 710,0 MAXX=319:MAXY=191 W=4:H=12.5 DO FOR YAXIS=40 TO MAXY-W STEP 30 FOR XAXIS=40 TO MAXX-H STEP 30 IF(RAND(10)=0) X=XAXIS:Y=YAXIS X1=X+W:Y1=Y+H COLOR 0 FOR YY=YAXIS-H TO YAXIS+H PLOT XAXIS-H,YY DRAWTO XAXIS+H,YY NEXT YY COLOR 1 FOR ANGLE=0 TO 157.5 STEP 22.5 IF (RAND(2)=0) RADANG=ANGLE*.01745:'CONVERT DEGREES TO RADIANS FOR A = 0 TO 6.28318 STEP 2/H X1=X+COS(A)*W Y1=Y+SIN(A)*H 'Rotation code from Bruce Artwick's book 'Microcomputer Displays, Graphics and Animation ROTX=XAXIS+((X1-XAXIS)*COS(RADANG)-(Y1-YAXIS)*SIN(RADANG)) ROTY=YAXIS+((X1-XAXIS)*SIN(RADANG)+(Y1-YAXIS)*COS(RADANG)) IF (A=0) PLOT ROTX,ROTY IX=ROTX:IY=ROTY ELSE DRAWTO ROTX,ROTY ENDIF NEXT A DRAWTO IX,IY ENDIF NEXT ANGLE ENDIF NEXT XAXIS NEXT YAXIS LOOP

#turbobasicxl atari #TurboBASIC XL #plotterart

[atariaction]

Lander: BASIC Tenliners Contest 2019 entry

Use the joystick controller to land your LEM (lunar excursion module) on a moon. Land on one of the green landing pads. The trigger fires the main thrusters, pushing the ship upward against the moon’s gravity. Left/right stick movement fires the side thrusters for horizontal movement.

A control panel shows your vertical speed (indicated by ↓), horizontal speed (→), strength of gravity on the moon (G), and amount of fuel (F). To land safely, you must touch down on a landing area with a vertical speed of 10 or less, and horizontal speed of 5 or less. Flying off the sides or the top of the screen is deadly. Running out of fuel is not recommended.

Each moon is a little different, with gravity ranging from light (G5 in the control panel) to heavy (G20.) Moons usually have one or two landing pads. (Rarely, you will come across a moon that has none! In this case you will die. I’m sorry. Space exploration is dangerous.)

The first Lunar Lander that I was exposed to was Atari’s vector arcade version, which seemed amazing — and impossibly difficult. Later, my dad bought the Adventure International version of Lunar Lander for his Atari 800. (It was one of the few pieces of Atari software that he didn’t pirate.) In that version, the LEM doesn’t rotate. Instead, side thrusters push the ship horizontally while it remains in a vertical position. I did the same in my version.

(That’s where I learned the word “hybrid.” The stats on the back of the box said “Language: Hybrid.” I wondered if that was some programming language I hasn’t heard of; dad explained that the word meant “a combination of two things.” In this case, BASIC and assembly language.)

Benj Edwards wrote a great history of Lunar Lander games that is worth reading.

I’ve wanted to program a Lunar Lander-type game since I was a teen. I’m pretty sure I tried it using shape tables on my Apple IIc in AppleSoft BASIC, and experimented with it in Atari BASIC at some point, but I never could get the movement with respect to thrust and gravity right. I didn’t have the math concepts. But in the past few weeks, with my buddy helping with the math for Bouncy; and reading Bruce Artwick’s book Microcomputer Displays, Graphics and Animation, I now know jussssst enough math to be dangerous with Atari graphics. So I was finally able to create a version of Lunar Lander, and in 10 lines of Turbo-BASIC XL.

For the contest, my program fits in the 120-characters-per-line category. In terms of cramming stuff into 10 lines, it’s some of my best work and I learned a lot. Several times I thought the program has to be done, there was absolutely no more room to squeeze in another feature. Then I’d find a way to do something in fewer bytes, making room for a tiny improvement elsewhere.

My favorite was replacing for-next loops to move or generate data with the MOVE statement, with copies memory around RAM. For instance, I needed to zero out Player (sprite) data. Normally I’d do that with FOR I=P+512 TO P+896:POKE I,0:NEXT I. But — MOVE DPEEK(88),P+512,384 does the same thing with fewer bytes (and much faster.) But I needed to copy from an area of RAM that is all zeros. Where would I find such a place? A newly blank screen is filled with zeros. At another point, I needed a mess of random-looking data for the ship explosion. I started with a FOR-NEXT loop writing RANDom numbers, but ended up moving random bits of data from the Atari ROM into sprite memory. Again, it was much faster and took of less precious program space.  I’m not implying at all that I invented this technique, but I figured it out on my own and it was satisfying.

Here’s the commented code:

'LANDER by Kevin Savetz 'March 22 2019 GRAPHICS 23:'GR. 7, no text window. 159x92 'normally y=95 for full GR.7 screen, we lose a little because text line at top DIM F0$(16),F1$(10) F0$="\00\00\00\00\3C\42\42\3C\42\7E\5A\81":'LEM graphic with blank spaces around 'to make erasing old LEM easy as it moves vertically 'F1$ is workspace for the P1 thrust flame FUEL=150:'starting fuel A=PEEK(106)-20:'set aside RAM for players POKE 54279,A:'PMBASE P=A*256:'top of P/M memory POKE 559,46:'Double line resolution P/M characters VX=-5+RAND(11):'Initial X speed POKE 53277,2:'turn on players (not missiles) M=DPEEK(88):'top of screen RAM MOVE M,P+512,384:'zero Player data, copying 0s from the fresh blank screen POKE 704,88:'PCOLR0. I like purple. 'custom display list D=DPEEK(741):'location of display list POKE D+4,66:'top line is Graphics 0 text line (mode 2) -MOVE D+102,D+99,3:'shorten the display list so screen's not too tall POKE 752,1:'hide cursor 'draw terrain & stars/ground texture COLOR 1 PLOT 0,90-RAND(60):'start drawing terrain on left edge LPP=1:'first segment can't be landing pad FOR I=10 TO 150 STEP 10 Z=M+40+RAND(3500):'pick a location for star/ground texture POKE Z,PEEK(Z)!3:'draw it IF (LPP OR (RAND(5) OR LP=2)):'draw craggy rock if we just drew a landing pad 'or if we've already drawn 2. Otherwise, maybe draw a pad II=RAND(40)+52:'rock height COLOR 1:'color of rock LPP=0:'remember that last thing drawn isn't a pad ELSE COLOR 2:'color of pads LP=LP+1:'count number of landing pads LPP=1:'remember last thing drawn is a pad ENDIF DRAWTO I,II:'draw the rock/pad NEXT I COLOR 1 DRAWTO 159,60 PAINT 159,92 DT=.05:'Time increment. Lower numbers make the game slower X=50+RAND(125):'Initial X Y=520:'Initial Y G=RAND(15)+5:'Strength of gravity VY=1+RAND(10):'Initital Y speed DO:'main loop POKE 53278,0:'Clear PM collisions X=X+VX*DT:'change LEM's X POKE P+Y+264,0:'clear side thrust Y=Y+VY*DT:'change LEM's Y VY=VY+G*DT:'new Y speed POKE 53248,X:'HPOSP0 position LEM at new X MOVE ADR(F0$),P+Y,16:'draw LEM at new vertical position 'clean up from last move... -MOVE M,P+Y+136,12:'copy 0s from top corner of screen to erase flame (if any) SOUND:'stop thrust sound if any 'thrust. Player 1 is the bottom thrust flame IF FUEL AND STRIG(0)=0:'if trigger and have fuel VY=VY-2:'decrease vertical speed MOVE ADR(F1$),P+Y+136,10:'place flame 8 lines below P0 SOUND 0,50+Y,8,8:'I KNOW, there's no sound in space POKE 53249,X:'P1 X position POKE 705,50+RAND(11):'flame color FOR Z=3 TO 8 POKE ADR(F1$)+Z,RAND(16)*4:'rows of random flame, but only 4 bytes 'in the middle so it isn't too wide 00111100 NEXT Z FUEL=FUEL-1:'reduce fuel ELSE:'if no trigger, check for left/right thrust. Player 2 is the side thrust flame S=STICK(0) Z=(S=7)-(S=11):'get joystick left-right status IF Z AND FUEL AND NOT FIRE:'if joystick and have fuel and LEM isn't thrusting up POKE P+Y+264,3:'put P2 flame at correct vertical position relative to LEM POKE 53250,X-3+(4*Z):'side flame on left or right of LEM POKE 706,50+RAND(11):'P2 color VX=VX-Z:'change X speed SOUND 0,50,8,8:'noise FUEL=FUEL-1 ENDIF ENDIF POKE 87,0:'get ready to print in text window 'If LEM goes off screen or hits terrain or hits landing pad too fast IF X<40 OR X>205 OR Y<510 OR PEEK(53252)&1 OR (PEEK(53252)&2 AND (VY>10 OR ABS(VX)>5)) FOR Z=1 TO 250:'explosion SOUND 0,50+RAND(30),6,8:'in space no one can hear you scream MOVE 59740+RAND(500),P+Y+4,12:'copy random data from ROM to P1 POKE 704,50+RAND(21):'P1 color NEXT Z RUN:'restart ENDIF 'show speed, gravity, and fuel POS. 14,0:?"\1B\1D";INT(VY);" \1B\1F";INT(VX); ?" \C7";G;" \C6";FUEL;" " IF(PEEK(53252)&2):'touched landing pad, make happy music & restart SOUND 0,121,10,10:PAUSE 80 SOUND 1,81,10,10:PAUSE 80 SOUND 2,60,10,10:PAUSE 150 RUN ENDIF LOOP

#atari #lunar lander #TurboBASIC XL #BASIC

[atariaction]

Bomber: BASIC Tenliners Contest 2019 entry

My sixth entry in the 10-line BASIC contest is Bomber, a Kaboom! clone. It’s written in Turbo BASIC XL and fits in the PUR-120 category. You need a paddle controller and quick reflexes to catch the mad bomber’s falling bombs. The game ends when you miss five bombs. You earn one point for catching a bomb, and lose an increasing number of points for missing them.

Here's the code:

A=PEEK(106)-4:POKE 106,A:PM=A*256 'Where player missile data goes DIM F$(24),B(9),VOL(9) 'F$=character set data. B=bomb position (0 if inactive) 'VOL=volume of sound channels. (Only 0-3 are used.) GRAPHICS 17:'I love this graphics mode LV=10:'level starts at 10, goes down to 2. It's weird but player doesn't see that info. SB=2:'"audio channel available for boom sound starts at 2 SC=DPEEK(88):'top of screen RAM CH=(PEEK(106)-16)*256:'find RAM for character set POKE 712,$D6:'background color POKE 708,0:'bomber color F$="\02\08\10\38\74\7C\7C\38\38\7C\D6\D6\7C\6C\38\54\FE\82\FE\82\FE\C6\44\44" 'character set '1 = \02\08\10\38\74\7C\7C\38 = bomb '2 = \38\7C\D6\D6\7C\6C\38\54 = top of bomber '3 = \FE\82\FE\82\FE\C6\44\44 = bottom of bomber MOVE 57344,CH,1024:'Copy character set to RAM MOVE ADR(F$),CH+8,24:'install custom characters POKE 756,CH/256:'switch to RAM chatacter set POKE 53256,3:POKE 54279,A:POKE 559,46:POKE 53277,3:POKE 53248,130:POKE 704,10:POKE 53278,0 'Set up Player/Missile graphics FOR I=0 TO 512:DPOKE PM+I*2,0:NEXT I:POKE PM+618,$3F 'Empty the P/M area that we need. Draw the line that player controls. 'MAIN LOOP WHILE M<5:'go until player misses 5 bombs BD=RAND(20):'bomber destination 'MOVE PLAYER PADDLE WHILE BD<>BX P=180-PADDLE(0) IFP<37:P=37:ENDIF POKE 53248,P:'HPOSP0 'CAUGHT BOMB? IF PEEK(53252):'P0PF collision? FOR X=0 TO 9:'test every bomb IF B(X)>419:'if it's on bottom level of screen POKE SC+B(X),0:'erase it B(X)=0:'mark it inactive S=S+1:'increase score G=G+1:'"got" counter for stats ENDIF NEXT X POKE 53278,0:'clear P/M collision SG=SG+1:SG=SG*(SG<2):VOL(SG)=6:'happy beep POSITION 1,0 ?#6;S;" ":'update score ENDIF 'DROP A NEW ONE IF(RAND(LV)=0):'As level decreases, bombs drop more frequently POKE SC+80+BX,65:'draw bomb at top of screen B(C)=80+BX:'mark it as active C=C+1:'iterate 0-9, which bomb gets dropped next C=C*(C<10) ENDIF 'REM MOVE EXISTING BOMBS FOR X=0 TO 9 IF VOL(X):'make/update boom and beep noises for sound channels 0-3 VOL(X)=VOL(X)-2:'if channel has volume, make it quieter SOUND X,60,10-(X>1)*2,VOL(X):'update sound channel '^ channels 0-1 are pure tone beep, 2-3 are noisy boom. ENDIF IF B(X):'if bomb is active POKE SC+B(X),0:'erase old bomb position B(X)=B(X)+40:'move it down one row IF (B(X)>479):'if it's at the bottom B(X)=0:'mark it inactive S=S-(11-LV):'lose points for missing it M=M+1:'missed counter SB=SB+1:IF(SB=4):SB=2:ENDIF:'get channel for boom sound VOL(SB)=14:'queue up boom POSITION 1,0:?#6;S;" ":'update score ELSE POKE SC+B(X),65:'not at the bottom, redraw in new position ENDIF ENDIF NEXT X 'MOVE BOMBER Z=SC+40+BX:'bomber screen position POKE Z,0:'erase bomber top POKE Z+20,0:'and bottom BX=BX+(BX<BD):'move toward destination BX=BX-(BX>BD):'or in the other direction POKE SC+40+BX,2:'draw bomber top POKE SC+60+BX,3:'and bottom WEND:'WHILE BD<>BX - bomber has reached his destination... T=T+1:'increase number of trips tally IF (T=35):'if he's made enough trips LV=LV-(LV>2):''Reduce level number, minimum is 2. T=PEEK(712)-$10:'new level, new background color T=T+(T<6)*$D6:'don't let bg color get negative POKE 712,T:'change background color T=0:'Reset trip counter POKE 77,0:'inhibit attract mode ENDIF WEND :'WHILE M>5 'GAME OVER SOUND:'quiet POS. 0,0 POKE 712,10:'black background ?#6;"GAME OVER" ?#6;"SCORE: ";S ?#6;"ACCURACY: ";TRUNC((G/(G+M))*100);"%" WHILE PTRIG(0):WEND:RUN

#atari #TurboBASIC XL #Kaboom!

[atariaction]

Bouncy: BASIC Tenliners Contest 2019 entry

My fifth 10-line BASIC contest entry is Bouncy, a throw-the-ball-into-the-goal game loosely based on "Cup" by Jonathan Freidin from the 1979 book "More BASIC Computer Games." I have never actually played Cup, but read the sample game and code in the classic red book many times over as a kid.

The goal of Bouncy is to throw your ball into the target (not a cup, but a line in my version, so totally different.) Use the joystick to adjust the ball's initial speed (from 10 to 50 speed-o-units) and angle (from an almost-level 10 degrees to a skyward 60 degrees.) Press the trigger to throw the ball. If it falls into the goal or bounces in, you win. (Hitting the goal from below doesn't count.) If you miss, the goal remains unmoved: you can adjust your throw to try again.

My friend Mitch helped and helped with the hard math. (The math in this game is a lot more complected than Cup's!) The game is just eight 120-character lines in Turbo BASIC XL on the Atari, so it goes into the PUR-120 contest category.

'BOUNCY by @KevinSavetz 'with massive math help from @pneumaticdeath's math skills 'Jan 7 2019, for the 2019 BASIC 10-line contest W=1:'W is "did we win?" if yes (or 1st time) change goal position XMAX=159:'GR 7 YMAX=92:'95 for full GR.7 screen, we lose a little because text line at top DO GRAPHICS 7+16 DL=DPEEK(741):'location of display list POKE DL+4,66:'change top line to Graphics 0 text line (ANNTIC mode 2) -MOVE DL+102,DL+99,3:'shorten the display list so screen's not too tall 'POKE DL+99,PEEK(DL+102):DPOKE DL+100,DPEEK(DL+103):'another way to do it POKE 752,1:'hide cursor IF W:'if player just won (or first time), place goal in new random position CX=RAND(XMAX-30)+20:'goal x CY=RAND(YMAX-15)+15:'goal y CW=10:'goal width W=0 ENDIF COLOR 1 PLOT CX,CY:DRAWTO CX+CW,CY:'draw goal POKE 87,0:POS.0,0:'draw control interface on the GR.0 part ?"BOUNCY ANGLE: 10 SPEED: 10 AIM " WHILE STRIG(0):'joystick to adjust andle and speed. Trigger to fire. S=STICK(0) AI=AI+((S=14)-(S=13))*5:'up/down to adjust angle VI=VI+((S=7)-(S=11))*5:'left/right to adjust velocity IF AI<10:AI=10:ENDIF:'keep angle and velocity in range IF AI>60:AI=60:ENDIF IF VI<10:VI=10:ENDIF IF VI>50:VI=50:ENDIF POS.15,0:?AI;" " POS.26,0:?VI;" " PAUSE 10 WEND POS.30,0:?" ":'erase AIM POKE 87,7:'get ready to draw in the GR.7 part POKE 77,0:'defeat attract mode 'launch ball! COLOR 2 T=0:'TIME COUNTER LB=0:'LAST BOUNCE TIME DT=.03:'TIME INCREMENT X=1:'INITIAL X Y=10:'INITIAL Y G=12:'GRAVITY E=.6:'ELASTICITY A=AI*.01745:'CONVERT DEGREES TO RADIANS. .01745 IS (3.14159/180) VX=VI*COS(A):'X VELOCITY VY=VI*SIN(-1*A):'Y VELOCITY DO:'move/bounce ball T=T+DT:'time passes... X=X+VX*DT:'increment X Y=Y+VY*DT:'increment Y VY=VY+G*DT:'change velocity IF Y>YMAX:'BALL HIT BOTTOM. CHANGE TRAJECTORY TO BOUNCE IT VY=VY*-E:'adjust speed for bounce DY=Y-YMAX:'switch to upwards movement Y=YMAX-DY*E IF X>=XMAX OR T-LB<1.5:'TINY BOUNCING AT THE END, QUIT EXIT ENDIF LB=T:'LB=TIME OF LAST BOUNCE FOR I=250 TO 50 STEP -6:SO.0,I,10,10:NEXT I:SOUND:'BOUNCE SOUND ENDIF IF X<XMAX AND Y>1:'We already know Y<YMAX because IF above PLOT X,Y:'draw ball if it's onscreen 'Set win flag if ball hit the goal while falling IF X>=CX AND X<=CX+CW AND VY>0 AND (INT(Y)=CY OR INT(Y)=CY-1) W=1 EXIT ENDIF ENDIF LOOP POKE 87,0:POS.30,0:'print win or lose status IF W ?"WIN!" ELSE ?"MISS" ENDIF FOR I=0 TO 15:SOUND 0,50*(3*(NOT W))+50,10,15-I:NEXT I:'DING FOR WIN, BOOP FOR MISS POKE 87,7:'back to playing in GR.7 area PAUSE 200 LOOP

#atari 800 #TurboBASIC XL

[atariaction]

Mini Character Editor: BASIC Tenliners Contest 2019 entry

One of the great features of the Atari computers was the ability to redefine the character set. Normally, the character set — the collection of letters, numbers, punctuation, and special symbols that the computer can display — is pulled from ROM, where it can’t be changed. But the Atari had the ability to look elsewhere in memory for the character set. Using that feature, you could create customized characters, put them in RAM, then tell the computer to use your custom character set. With that, you might change the standard letter A into a fancy script A, or into a little spaceship.

Back in the day most of us used Atari BASIC, and you could tell when a game was going to use a custom character set: PLEASE WAIT. When that message appeared, it would mean a delay of 30 to 40 seconds while the program copied the character set from ROM to RAM. Actually installing custom characters was very fast; the slow-verhead was in BASIC copying the whole set around memory. If a programmer was sophisticated enough to write a machine language subroutine, the same job could be done in a fraction of a second. I certainly wasn’t, and apparently neither were most of the programmers who had type-in games published in Compute!, Antic, and other computer magazines.

Happily, TurboBASIC XL has a memory move command, which does same work with the speed of machine language, removing the interminable wait to copy characters around.

Here’s how I set up a custom character set in another program I wrote, Poke Pig:

CH=(PEEK(106)-16)*256:’Define a chunk of RAM under the “top” of BASIC’s memory space. This is enough space to hold the character set. The memory location of the start of that space is put into variable CH.

MOVE 57344,CH,1024:’Copy the character set from its location in ROM (it starts at 57344 and is 1024 bytes) to the space we set aside in RAM. This is the part that used to take 30-40 seconds.

DIM F$(8):’This program only defines one special character, which will replace the # character. We’ll put the data for this character in F$. We need 8 bytes for that character data. Changing two characters would take 16 bytes, and so on.

F$="\E7\DB\81\42\99\99\42\3C":'Here’s the data for the new # character. Here it’s a bunch of hex numbers. In the listing that will be represented by a mess of eight ATASCII characters. The Mini Character Editor program generates these hex numbers (and the ATASCII version) based on your drawing.

MOVE ADR(F$),CH+24,8:’Copy the custom character, in F$, which is 8 bytes, replacing the # character, which is located at CH+24.

POKE 756,CH/256:’Tell the computer to start using our copy of the character set instead of the official ROM version.

So, that mess of hex codes in F$. Each hex number represents one row in the eight lines of a character. Normally I would draw the 8x8 character on graph paper, then convert each row to its binary number, then convert that number to its hex or ATASCII equivalent.

The Mini Character Editor program lets you draw a character using the joystick, see it instantly in the Atari’s five graphics modes (BASIC modes 0,1, 2, 4 and 5), and see the hex code and ATASCII string so you can install that graphic in your own program.

In addition to drawing with the joystick, there are four keyboard commands for manipulating the graphic: H for horizontal flip, V for vertical flip, D to move everything down one line, R to move everything right one space.

When you’re ready to install the graphic in your own program, copy down the hex numbers by hand (there are only 8 of them!) or BREAK out the program and type_ ?A$_ to get the ATASCII version to export into your program. 

Mini Character Editor fits in ten 120-character lines. Because it is not a game, i qualifies for the WILD category of the 10-line BASIC contest. I think it’s my first program to use a custom display list, which I (re?)learned about from the book The Creative Atari.

Here's the code:

'mini character editor 'Feb 3 2019 by @KevinSavetz 'use joystick to design a character set character 'H=horizontal flip, V=vertical flip 'D=move everything down, R=move everything right DIM F$(8),F(9) 'F in the main container for the data of the drawn character. 'F$ contains the data in string format GR.3:POKE 752,1 'start with BASIC mode 3, but we'll tweak that later. Turn off cursor. CH=(PEEK(106)-16)*256 'space for custom character set SC=DPEEK(88) 'top of screen RAM 'set up display list DL=DPEEK(741):'display list POKE DL+16,4:'MODE 4 @ SC+100 POKE DL+17,5:'MODE 5 @ SC+140 POKE DL+18,6:'MODE 6(BASIC MODE 1) @ SC+180 DPOKE DL+19,1799:'2 LINES OF MODE 7(BASIC MODE 2) @ SC+200 & SC+220 DPOKE DL+21,514:'2 LINES OF MODE 2(BASIC MODE 0) @ SC+240 & SC+280 POKE DL+23,0:'skip a line POKE DL+24,2:'2 LINES OF MODE 2(BASIC MODE 0) @ SC+320 & SC+360 FOR I=25 TO 31:POKE DL+I,0:NEXT I:'many blank lines 'print ! characters in the various screen modes FOR I=SC+100 TO SC+280 STEP 40 POKE I,1:POKE I+3,1:POKE I+4,1 NEXT I 'and some more in the text window ?"! ! !! !!!" ?" ! !! !!!" 'install RAM character set MOVE 57344,CH,1024 'replace ! with our custom character MOVE ADR(F$),CH+8,8:POKE 756,CH/256 'draw box around editing window COLOR 3:PLOT 0,0:DRAWTO 9,0:DRAWTO 9,9:DRAWTO 0,9:DRAWTO 0,0 X=1:Y=1 'main loop DO IF R<0:'re-draw contents of editing window FOR J = 1 TO 8:'for each row in the byte... FOR I = 1 TO 8:'look at each bit... COLOR SGN(F(J) & (2^((9-I)-1))) 'set color to 1 if the bit is set, 0 if not PLOT I,J:'draw the bit NEXT I NEXT J ENDIF IF R:'if R<>0, update hex/ATASCII display POKE $57,0:'prepare to print in text window ?CHR$(156);:'clear the text line FOR I=1 TO 8 F$(I,I)=CHR$(F(I)):'copy the data to F$ ?"\";HEX$(F(I));:'show the 8 bytes as hex NEXT I:?" "; FOR I=1 TO 8:'show the 8 bytes as ATASCII IF F(I)<>155 ?CHR$(27);CHR$(F(I));:'normal case ELSE ?" ";:'if character is CR (27) show space instead. CR messes display. ENDIF NEXT I POKE $57,3:'back to drawing in GR.3 MOVE ADR(F$),CH+8,8:'copy the new character to the active character set ENDIF R=0:'redraw defaults to off COLOR SGN(F(Y) & (2^((9-X)-1))): PLOT X,Y:'draw current bit S=STICK(0):'get joystick position Y=Y+((S=13)-(S=14)):'move up/down? X=X+(S=7)-(S=11):'move left/right? IF X<1:X=8:ENDIF:'stay in bounds of the drawning box IF Y<1:Y=8:ENDIF IF X>8:X=1:ENDIF IF Y>8:Y=1:ENDIF P=PEEK(764):'was a key pressed? IF (P=58):'d to move everything down FOR J=9 TO 1 STEP -1:'for each byte F(J)=F(J-1):'copy every byte to next byte. F(9) is temp storage only. NEXT J F(1)=F(9):'move bottom line to top R=-1:'put in order for full redraw ENDIF IF (P=40):'r to move everything right FOR J=1 TO 8:'for each byte Q=F(J) & 1:'copy rightmost bit (LSB) to temporary storage Q F(J)=TRUNC(F(J)/2):'divide byte by 2 to shift bits right F(J)= F(J) + 128*Q:'copy old rightmost bit to leftmost bit NEXT J R=-1:'put in order for full redraw ENDIF IF (P=57):'h for horizontal flip FOR J=1 TO 8:'for each byte Q=0:'working byte FOR I=1 TO 8:'for each bit in the byte Q=Q+(SGN (F(J) & (2^(I-1))) * 2^((9-I)-1)) 'add to working byte: ' SGN [make 0 or 1] ( ' (the current row bitwise-and ' the value of the current bit (1,2,4,8,16...))) ' * the value of the opposite bit (128,64,16,8,4...) 'So: if the 1 bit is on, add 128 to the working byte, 'if the 2 bit is on, add 64 to the working byte, and so on. 'This was not easy to figure out, nor to figure out all over 'again the next day to write these comments NEXT I F(J)=Q:'install reversed byte NEXT J R=-1:'put in order for full redraw ENDIF IF (P=16):'v for vertical flip FOR J=1 TO 4:'for bytes 1 to 4 Q=F(J):'temp copy of byte F(J)=F(9-J):'copy 8 to 1, 7 to 2, 6 to 3, 5 to 4 F(9-J)=Q:'copy 1 to 8, 2 to 7, 3 to 6, 4 to 5 NEXT J R=-1:'put in order for full redraw ENDIF ' there was no room for this, but might be fun to add ' IF (PEEK(764)=45):'t to turn (rotate) ' ENDIF POKE 764,255:'clear keyboard buffer IF(STRIG(0)=0):'if trigger is pressed F(Y) = F(Y) EXOR (2^((9-X)-1)):'toggle current bit R=1:'only redraw hex/atascii PAUSE 4:'slow things down a tad ENDIF COLOR 2:PLOT X,Y:'show cursor PAUSE 4 LOOP

#atari 800 #TurboBASIC XL #character set

[atariaction]

MINILIFE: BASIC Tenliners Contest 2019 entry

Back to my personal theme for 10-liner entries — classic BASIC algorithms. It’s hard to get more classic than Conway’s Game of Life. This simple game/simulation was covered so times from many perspectives in Byte Magazine, Creative Computing, and so on. I used the algorithm as described by Mark D. Niemiec in the January 1979 issue of Byte for my 10-liner.

My program lets you edit the starting playfield configuration, run the simulation, then optionally stop the sim to edit the playfield before continuing. At 80 characters per line, this program would fit in PUR-80, the most restrictive contest category. But after writing it I learned that the contest rules say that the PUR-80 category is limited to versions of BASIC that ship with the computer — e.g. Atari BASIC for the Atari 8-bit line. Since I wrote MINILIFE in TurboBASIC XL, and can’t convert it to Atari BASIC without making it significantly longer, I will submit it to the PUR-120 category. Boo.

GR.3 HY=10:'MAX 19 - playfield height HX=20:'MAX 39 - playfield width. Bigger playfield makes it slower. DIM OLD(HY+1,HX+1),NW(HY+1,HX+1):'arrays for old and new playfield 'draw bounding box COLOR 3:PLOT 0,0:DRAWTO HX+1,0:DRAWTO HX+1,HY+1:DRAWTO 0,HY+1:DRAWTO 0,0 ?"MINILIFE" 'Edit cells with joystick. DO X=1:Y=1:?"Edit mode. Place cells then SPACE." POKE 764,255:'clear keyboard buffer WHILE PEEK(764)<>33:'until SPACE is pressed... COLOR NW(Y,X):PLOT X,Y:'show cell in current position S=STICK(0) Y=Y+((S=13)-(S=14)):'move up/down X=X+(S=7)-(S=11):'move left/right IF X<1:X=HX:ENDIF:'stay in bounds IF Y<1:Y=HY:ENDIF IF X>HX:X=1:ENDIF IF Y>HY:Y=1:ENDIF IF(STRIG(0)=0) NW(Y,X)=NOT NW(Y,X):'toggle cell on/off PAUSE 3 ENDIF COLOR 2:PLOT X,Y:'show cursor PAUSE 4 WEND 'now run the sim IT=0:?"Generating life. SPACE to stop." POKE 764,255 DO 'draw the current colony FOR Y = 1 TO HY FOR X = 1 TO HX COLOR 3:PLOT X,Y OLD(Y,X)=NW(Y,X) COLOR OLD(Y,X) PLOT X,Y NEXT X NEXT Y IF PEEK(764)=33:EXIT:ENDIF:'SPACE = back to editor 'calculate the next generation. Read the Byte article :) FOR Y = 1 TO HY FOR X = 1 TO HX SUM=OLD(Y-1,X-1)+OLD(Y-1,X)+OLD(Y-1,X+1)+OLD(Y,X-1)+OLD(Y,X+1)+OLD(Y+1,X-1)+OLD(Y+1,X)+OLD(Y+1,X+1) IF SUM=3 NW(Y,X)=1 ELSE IF SUM=2 NW(Y,X)=OLD(Y,X) ELSE NW(Y,X)=0 ENDIF ENDIF NEXT X NEXT Y IT=IT+1:?IT:'iteration counter LOOP LOOP

#atari800 #turbobasicxl atari #conway's game of life #conwayslife #ByteMagazine

[atariaction]

Poke Pig: BASIC Tenliners Contest 2019 entry

My third grade teacher hated me and told my mom that I would grow up to be a serial killer. (This turned out to be inaccurate.) She also taught me the dice game “Pig.” In our class, the teacher would roll two dice again and again. Students would add each dice roll to their score, and could quit at any time. But if the teacher rolled snake eyes, the game was over, and any students still playing were out with zero points.

My second 10-line BASIC contest entry is loosely based on the Pig game. It is a ridiculous self-modifying program — instead of rolling dice, it pokes random numbers into random memory locations owned by BASIC. The player can choose how many random memory locations to POKE for points. The player wins if they quit before the game crashes.

I doubt the judges will like it, but I think it's hilarious. It fits into the Pure-120 character category.

MULT=1:'multplier increases for higher score offer as game progresses DIM A(7),F$(8) F$="\E7\DB\81\42\99\99\42\3C":'piggy face character A(4)=50:A(5)=100:A(6)=250:'number of POKE choices 'instruction screen GR.0 ?"POKE PIG" ?"Choose how many random memory" ?"locations to POKE for points." ?"You win if you quit before" ?"the game crashes. If it crashes," ?"you lose.":?:?"Press trigger." WHILE STRIG(0):WEND 'setup screen GR.2:POKE 710,0:POKE 708,$4A 'move character to RAM so it'll get mangled CH=(PEEK(106)-16)*256:MOVE 57344,CH,1024 'install custom pig face charcter MOVE ADR(F$),CH+24,8:POKE 756,CH/256 LM=DPEEK(128):'lomem MT=DPEEK(741):'memtop. We're going to only poke memory owned by BASIC. Staying out of page zero, the display list, etc. DO POS.0,0 ?#6;" # poke pig #" ?#6;"YOU HAVE ";S;" POINTS" POS.0,3 ?#6;"CHOOSE:" FOR D=4 TO 6 ?#6;" ";A(D);" POKES +";INT((A(D)*D*MULT)/2);"PTS" NEXT D ?#6;" OR...QUIT NOW" PAUSE 20 D=4 'choose item from menu WHILE STRIG(0) POS.0,D:?#6;" " D=D+((STICK(0)=13)-(STICK(0)=14)) IFD<4:D=4:ENDIF IFD>7:D=7:ENDIF POS.0,D:?#6;">" PAUSE 5 WEND 'chose Quit IF A(D)=0 POS.0,8 ?#6;"YOU WIN WITH ":?#6;S;" POINTS!" IF S ?"Coldstart now. Really." ELSE ?"Wimp." ENDIF END ENDIF 'choose to POKE. MAX=A(D) FOR X=1 TO MAX POSITION 8,9 ?#6;MAX-X;" " POKE RAND(MT-LM)+LM,RAND(256) Y=50-X*2 IF Y>0 PAUSE Y:'speeding up as it works is fun ENDIF SOUND 0,99,10,10 PAUSE 2 SOUND NEXT X S=S+INT((A(D)*D*MULT)/2) MULT=MULT*1.25:'next points offer is higher LOOP

#atari800 #turbobasicxl atari

[atariaction]

Floody Bot: BASIC Tenliners Contest 2019 entry

I love the BASIC 10-Liner contest! I didn’t find the time/energy/whatever to enter in 2018, so am excited to write some short BASIC programs for this year’s contest. First out of the gate is Floody Bot. This will be an entry for the EXTREME-256 category.

My soft overarching theme for entries this year is classic BASIC algorithms. Floody Bot started with the kernel of Maze Generator by Charles Bond, which was published in Compute! Magazine Issue 19.

In this game, you play the part of a rescue bot entrusted to save humans from rising flood waters. Touch a human to save them. You must rescue three or more humans to proceed to the next level. As levels increase, the flood waters rise more quickly. Oh, the bot can’t swim.

Once per level, you can press the fire button to set off a bomb destroying everything in your horizontal row. This can get you out a sticky situation. If your bot gets stuck, press START to self-destruct. (If you’ve already rescued three or more humans, you’ll move on to the next level with a new bot.)

Earn points for rescuing humans (lower-down humans are worth more.) Lose a lot of points if your bomb kills a human. (You don’t lose points if flood waters kill a human.)

Let’s look at the code:

GRAPHICS 17:DIM F$(48),A(5):CH=(PEEK(106)-16)*256

Set up graphics screen — graphics 1 with no text window. Save space for strings. F$ is for the custom character set. Array A is for maze generation. CH is the location of the character set in RAM.

F$="\FB\FB\FB\00\DF\DF\DF\00\08\61\B4\D0\66\0B\2D\86\7E\42\42\7E\99\7E\BD\66\3E\2A\14\3E\5D\1C\36\77\80\51\2A\04\80\45\2A\10"

This mess of ATASCII is the custom characters.

MOVE 57344,CH,1024:MOVE ADR(F$),CH+8,40:POKE 756,CH/256

Install the custom characters.

A(0)=2:A(1)=-40:A(2)=-2:A(3)=40 SC=DPEEK(88):

Top of screen memory

DO :'main loop

Set up level:

A=SC+21+(16*RAND(2))

Robot starts in either upper corner

G=0:GG=0:L=L+1:BM=1

G=number of guys to collect. I’m not being sexist. It’s a legacy variable because the humans were originally Gems. GG=number of Guys Got (saved). increase level, you have one bomb

W=16*(L+3)+8:WHILE W>255:W=W-258:WEND:POKE 710,W:

Change the brick color per level.

POKE 709,136 POKE 711,56

Set water and bomb colors.

POSITION 0,0 FOR I=1 TO 23:FOR J=1 TO 19:?#6;"\A1";:NEXT J:?#6:NEXT I

fill screen with bricks

COLOR 161:TEXT 11*RAND(2),15,CHR$(64+L)

draw the level letter in either lower corner in bricks 161=129 (Wall character) + 32 for the correct color

POKE 708,0

Hide character set while drawing maze. (It’s fun to watch but might be confusing.)

Now we get into the maze generation. It was a lot of work to tighten up the tangled original code and make it work without GOTOs, but that’s necessary for 10-liners.

POKE A,5 

place a marker at the maze starting point

MR=1:

MR=1: Start with a Random number. MR=0: iterating 

REPEAT BT=1

BT=0: blazing a new path. BT=1: we're BackTracking

IF MR

MR=do we want a random number to start looking for a valid direction?

J=INT(RND(0)*4):X=J

J=pick a random direction. X=remember our starting dir.

ENDIF B=A+A(J)

look forward to possible next space

IF PEEK(B)=129

is it a wall character? Make it a hallway 

POKE B,J+1

leave appropriate bread crumb for backtracking

POKE A+A(J)/2,0

draw hall character on the even column 

A=B

possible next space promoted to new space

MR=1:BT=0:

we'll pick a random direction to go from here

ELSE

its not a wall, so we can't use it. check another direction

J=(J+1)*(J<3):'iterate 1-2-3-0-1-2-3... IF J<>X MR=0:BT=0

we haven't tested all 4 yet, so look in next direction

ENDIF ENDIF IF BT:

we've tried all 4 directions with no luck. Time to backtrack

J=PEEK(A):

Get breadcrumb on current space

W=PEEK(A-1)+PEEK(A+1)+PEEK(A-20)+PEEK(A+20)=387*(J<5) POKE A,4*W

if there walls on 3 sides, it's a dead end, so draw guy (chr 4) (except on the staring spot: no guy there) else draw hall character (0) to erase unsightly breadcrumb.

G=G+W

G=number of guys to collect

A=A-A(J-1)

change current space to the one pointed to by the breadcrumb

ENDIF UNTIL J=5 

when we've backtracked back to the starting point, maze is done!

IF G<6 :GG=9:G=0:L=L-1:LOOP:ENDIF

If the maze generated fewer than 6 people, it's not good, give up and create another. This is hacky but oh well.

POKE 708,26

Reveal character set

We’ve finally built the screen, now we can play the game!

WL=23:'initial water level C=100-L*10:'countdown before water first appears.

C=C+(25-C)*(C<25)

Tidy way of doing C<25 then C=25

REPEAT POKE A,3 PAUSE 5

The actual game loop. Draw the bot. Pause to slow the game down a bit. J=STICK(0) B=A+(J=7)-(J=11) B=B+20*((J=13)-(J=14))

Potential new bot position based on joystick input.

IF PEEK(B)=0:POKE A,0:A=B:SOUND 0,99,6,8:SOUND:POKE 77,0:ENDIF

If that position is empty, move the bot to new position and make a little tick sound. Also defeat attract mode.

IF PEEK(B)=4:G=G-1:GG=GG+1

If robot touched a human, there’s one less human waiting to be saved. Increase counter of humans saved on this level.

S=S+L*((A-SC) DIV 20)

Increase score. Higher levels and deeper humans increase score more.

POKE A,0:A=B:POS.0,23:?#6;S;" ":SOUND 0,60,10,8:PAUSE 5:SOUND ENDIF

Erase human, update score display. Make a happy sound. 

IF PEEK(53279)<7:POKE A,2:SOUND 0,99,8,8:PAUSE 10:SOUND:EXIT:ENDIF

Press start to self-destruct. Make a sad sound, draw dead bot. Level over.

IF STRIG(0)=0 AND BM

If player pressed the fire button and has a bomb available...

BM=0

Used up the bomb.

Y=SC+20*((A-SC) DIV 20):

Compute player Y position. 

FOR W=-1 TO 0:

Drawing routine twice: first draw bomb fire then erase it

FOR X=1 TO 18:SOUND 1,50+X,8,8

up to 18 fire characters in either direction, with changing noise

FOR I=0 TO 1

iterate for left and right sides

IF I

don't extend past left edge

B=A-X

player screen position minus offset

J=B>Y:ELSE:B=A+X:J=B<Y+18:ENDIF

don't extend past right edge

IF J

IF PEEK(B)=4:G=G-1:S=S-25*L:POS.0,23:?#6;S;" ":SOUND 0,250,10,15:ENDIF

Aw, you're blowing up a human. There's one fewer guy onscreen. Lose points. Update onscreen score. Boop noise.

ENDIF POKE B,W*-194

draw, erase splody. chr=194, erase=0

ENDIF NEXT I NEXT X NEXT W SOUND ENDIF

Wrap up loops.

IF C<1:WL=WL-1

Time to raise the water level? Raise it.

C=60-5*L

countdown till it rises again. 

C=C+(10-C)*(C<10)

Maximum speed (IF C<10:C=10)

Next, draw water and make water sound:

FOR X=0 TO 18 SOUND 1,36-X*2,8,8 Z=SC+WL*20+X

Reduce guy count if it flooded a guy:

IF PEEK(Z)=4:G=G-1:SOUND 0,200,10,15:POKE Z,69:ENDIF 

IF PEEK(Z)=0:POKE Z,69:ENDIF

Draw flooding over guys and hall (but not walls)

NEXT X SOUND ELSE C=C-1:'tick down the timer ENDIF UNTIL G=0

Keep doing this until no people left onscreen.

IF GG>2 LOOP ENDIF

If 3 or more people saved, move on to next level.

POS.0,23:?#6;S;"   GAME OVER" WHILE STRIG(0):WEND:RUN

Otherwise show Game Over and wait for trigger to play again.

#atari800 #TurboBASIC XL

[atariaction]

Kevin’s 2018 Post-Mortem

Hello, it's 2019, which means it's time to look back on the computer history efforts that I made last year.

In 2018 I finished managing the Ted Nelson's Junk Mail scan project. Recap: from the mid-1960s to the mid-1990s, computing pioneer Ted Nelson collected catalogs, flyers, brochures, spec sheets, and sales slicks for products and services in a wide variety of industries. They ended up in the hands of the Internet Archive, and then (temporarily) in my hands, where every scrap was scanned and uploaded to the Internet Archive. In total, there were 17 bankers boxes stuffed with papers, totaling 70,266 sheets scanned. I bought scanners and hard drives, hired and managed the scanner-people (who were paid for their work with funds donated by many generous donors.) That project began in May 2017 and finished in October 2018.

Besides the Ted Nelson project, I scanned a metric ton of microcomputer history, including many dissertations and theses relevant to the Atari 8-bit, Apple II, CP/M, and the Votrax speech chip; user group newsletters; and rare historial documents about Atari computers and software. You can read it all at https://archive.org/details/@savetz

My goal for 2018 was to publish audio interviews with 50 people on the ANTIC podcast. I published exactly 50. This was down from 61 in 2017, but I met my goal and had conversations with wonderful people, many of whom had never been interviewed in the context of their computer history.

In the "big name" department I interviewed sci-fi author Orson Scott Card, who worked for Compute! Books back in the day. Also Bruce Artwick, creator of Flight Simulator II; and Dennis Koble, one of Imagic's co-founders. And Tom Snyder, the man behind Agent USA and Halley Project and Run For the Money and In Search of the Most Amazing Thing and Snooper Troops and and and...

But the most fun was chasing folks down crazy back alleys of computer history. I interviewed several of the kids from Atari's Youth Advisory Board, the group of children that Atari brought in for part market research/part marketing opportunity. I interviewed the creative team behind Bits & Bytes, a 1983 educational musical about computers. I talked with Brooke Alderson, who appeared in Atari TV commercials, and Rawson Stovall, who wrote a syndicated newspaper column about video games when we was just a kid.

(My side-quest to interview as many Atari Program Exchange programmers as possible continued. Of the 159 people who wrote APX software. 92 have been interviewed, 14 are known dead, 7 declined. That's 112 (70.4%) accounted for. The other 47 have proven reallyhard to find. I might squeak out a couple more eventually but I'm afraid we've reached the end of that road.)

Sometimes interviewees had importnat papers to be scanned and software to be digitized.

One of the folks who I interviewed was Hal Segal, who was founder of the Association of Time-Sharing Users, then the Association of Small Computer Users, which combined to become the Association of Computer Users. That's quite a mouthful, but Hal's organizations produced quite a lot of material: binders filled with newsletters, journals, benchmark reports, hardware directories, and literature from other computer companies. He lent it all to me: I scanned it all and uploaded it to Internet Archive — 2,625 pages total. There's information there about models of computers about which virtually nothing else is published online.

I interviewed Greg Gibbons, who was creator of Automated Library II, software for running a school library on an Apple II or Atari computer. He gave me the only remaining copy of the software and manuals, which I digitized and put online.

I interviewed Bob Ertl,who created REWRITE, an Atari word processor for math teachers, for his Master's thesis. The word processor was never published, but at my request, Bob digitized it and made several versions of the software, with source code, available to the world.  

Around the end of August, I was feeling done with interviews. Not exactly burned out, but I definitely needed a break, so I took one. After taking some time to reflect, here's what I'm feeling. I've interviewed more than 350 people since 2013, and have been able to talk with so many of the people that I personally wanted to talk with: the names I knew from being a kid nerd, and the people behind the companies that I admired. I've become friends with some of them. From a personal perspective, this has been incredibly satisfying, and from that perspective, I've talked to most of the people who were on my dream interview list. So while I know there are more stories, more people, more interviews that can be done (and that we're all getting older, so time is running out) my personal goals for interviews have largely been met. And this ismy hobby, after all.

Does this mean I'm done doing interviews? No! But I will continue to focus on talking with that people that interest me personally, and since most of those are done, the interviews will slow down. I'm not going to commit to a certain number of interviews in 2019.

My work will continue in other areas of computer history. There's a particular archiving project happening in 2019 that is really big and reallyimportant for microcomputer history. I'm not ready to talk about it, but hold your breath and cross your fingers.

Also in 2019 I plan to finish writing and publish a mini-book about the 20 Atari computer-related theses and dissertations that I've found. I’m continuing to play all of Infocom’s text adventures with @Carrington for the Eaten By A Grue podcast(14 games left to go.) The project with Rob McMullen to add new levels to my favorite computer game, Jumpman, is still on the back burner but not forgotten.

I’m proud of my computer history interviews and archiving work and am looking forward to another fun, productive year. There’s plenty more to do. Here we go!

#atari #atari800 #interviews #2018 #computer history #podcasts

[atariaction]

Kevin’s 2017 Post-Mortem

My goal for 2017 was to interview 50 people for ANTIC: The Atari 8-Bit Podcast. (That goal was a significant reduction from 2016, where I interviewed 146 people. I don’t know what sort of caffeine-fueled, adderall-enhanced cocaine I was on that year, but that was a crazy number of interviews to research, do, and publish, and I don’t intend to try that again.) For 2017, 50 interviews seemed a reasonable goal. I ended up publishing interviews with 61 people in 2017.

I interviewed some “big names” — these are the people that tend to get the most interest from casual listeners because the names are “famous” (for some value of famous.) Those included Dave and Betsy Ahl of Creative Computing magazine, Bill Stealey of Microprose, Carol Shaw of River Raid fame, and Robert Jaeger of Montezuma's Revenge fame. I was able to get some interviews that I had personally wanted for a long time (for varying values of long) such as River Raider Carol Shaw, author Linda Schreiber, prolific author Lance Leventhal, and KoalaPad creators David Thornburg and George White.

Some of my favorite interviews, though, were the ones that delved into strange, dark corners of Atari computing history. These the opposite of the “big name” interviews. These are the stories that no one has heard. Robert Veline owned a pyrotechnics company that used an Atari to run fireworks shows.  Sarah Haskell was (and still is) a weaver, and was one of the first people to use a computer-controlled loom. Randall Lockwood was (and still is) involved with pet rescue. He wrote a program called Choose-A-Pooch to help people pick the right dog breed for their lifestyle. Amy Chen worked at Atari, where she wrote an amazing 6502 assembly language debugger that was virtually unknown until I uncovered it.

(I had a side-quest to make sure that at least half of Atari Program Exchange programmers got interviewed. Achievement unlocked. 159 people wrote Atari Program Exchange software. As of right now, 86 have been interviewed — that’s 54%! 11 are known to be dead. 7 people declined interviews. That’s 104 accounted for.  The other 55 are increasingly hard to find.)

My goal for 2018 is another 50 interviews, and I already have some amazing people lined up in all of those categories. I can’t wait to hear what they have to say and share their stories with you.

During my interviews, I always ask if people have any material from back in the day that I can digitize. Hoo boy did they. I scanned thousands of pages of material and digitized lots of floppy disks in 2017. Highlights include the APX submission materials for “Knightsoil”, which would become Galahad and the Holy Grail; just about every scrap of paper and piece of software that Virtusonics created; unreleased games; unreleased utilities; rare manuals and catalogs from Eastern House Software; and innumerable Atari newsletters. Everything I scan gets uploaded to Internet Archive. (Give them your money.) Here’s the up-to-date list.

I also spent 2017 managing a project called Ted Nelson Junk Mail Archives. This project has spilled over into 2018, and should be finished by June or so. The short version of the story is that Ted Nelson (look him up in Wikipedia) saved boxes and boxes and boxes of tech catalogs, mailings, flyers, and brochures from the mid-1960s through the mid-1990s. I’m coordinating the digitization of all of it. It’s amazing material. As of the moment I’m writing this, we’ve scanned 45,000 pages from 12 bankers boxes. There are maybe 5 more boxes to go, but I just got word that they may have found a few more in storage. (Current stats are here.)

I have a plan for 2018 to uncover theses, dissertations, and other material about the Atari 8-bit computers that have never been widely published online or off. (If your thing is Apple II or Commodore or TRS-80 or whatever else, contact me and I’ll tell you how you can do the same for your favorite computer. My focus remains Atari computers.)

Side projects. When I’m not doing all of that, I’m still working on playing through all of Infocom’s text adventures with my buddy Carrington in our podcast called Eaten By A Grue. The project with Rob McMullen to add new levels to my favorite game, Jumpman, took a back seat in 2017, but I hope to get back to it this year.

I’m proud of my computer history interviewing and archiving work in 2017 and plan to keep moving forward with it in 2018. I love being a part of this community of computer historians and retrocomputing geeks. Not just Atari-loving people, but across the aisle with folks who enjoy any old platform, who tinker and build things, create podcasts, write magazines and books. There’s plenty to do in 2018. Let’s go!

#atari #atari800 #2017 #interviews #podcasts #computer history