72 page DRAFT getting started guide which will form part 1 (of 3) of the curriculum for the VCF East "Wildbits Classroom", which will be held at InfoAge in Wall Township, New Jersey on April 17, 18, 19.

This document is meant to be printed on 5.5 x 8.5" paper in folded booklet form.

See accompanying SuperBASIC examples, stored directly beneath this document.

.zip containing SuperBASIC examples to accompany the Getting Started draft, above.

2-page excerpt from the upcoming publish of Foenix Rising Issue #19 (mouse issue)

See the next file for the SuperBASIC example

This single screen SuperBASIC example demonstrates the mouse and accompanies Foenix Rising Newsletter issue #19.

It's a somewhat simple piece of code, but demonstrates how to read the mouse from SuperBASIC.  Doing so is trivial, but there are some complexities to deal with.

Also, this programming example, puts 64 sprites on the screen the old fashioned way (with Pokes and Peeks, no fancy SuperBASIC sprite commands).

The Newsletter that accompanies this program will be complete and posted by the end of February, 2025.  A 2-PAGE excerpt pertaining to this code is posted to the Foenix Marketplace, just above this file chronologically.

This game, coded by silk-neon was one several produced for the October 2024 Game-Jam.

GitHub link: https://github.com/ksiondag/fnxsnake

This is the five line SuperBASIC program discussed in the 8-Bit Wall of Doom YouTube video "F256 meets CBBS".

In case you were curious, here it is in plain text (no need to download it).

Foenix Rising Flash Issue #18 is a 6-page article discussing SuperBASIC, and a partially successful effort to port a vintage Commodore PET BASIC game to the F256.  Yes, the subject is "Ouranos", sometimes known as "Weather War", tag line "TAKE THE ENEMY BY STORM", originally written by Kathy Rigby and published in "Cursor" issue 21 in 1980.

There is still more to do in order to make this program ready for use; plenty of bugs exist and I'm still working on finishing an Intro to the game; but I ran into tons of problems during the port, and am here to share some of these stories to hopefully help other SuperBASIC programmers.

As prior, there is plenty of vintage nostalgia thrown in and a few references and videos to explore for more info.

This is revision "a." of the documentation and pertains to the .zip file which was published on November 5th.

This file replaces the .pdf included in the .zip

sake is an iteration of sak (stand-alone-keys), which was discussed in the December (Issue #13) of the Foenix Rising Newsletter. 

sake provides a visual interface to MicroKernel Keyboard, Joystick, and Mouse events and is useful in capturing codes which can be used within your programs which rely on MicroKernel events.

Of course, nothing is easy... there are peculiarities that exists between keyboards and maybe even versions of MicroKernel that you may have installed in your computer.  Using this utility, you can press given combinations of keys to see how they compare between systems and then choose to build an interface that will work across multiple systems without guesswork.

This utility was developed on an F256 Jr. using a PS/2 keyboard but tested across two different versions of FPGA code, and an additional derivation on an F256K.  Finally, a Commodore 64 keyboard, attached via optional hardware to the 6522 based Jr. connector was tested.

The file contains 3 versions, hard coded for load addresses $2000, $4000, and $6000, the latter two of which are compatible with SuperBASIC plus a .pdf single-page document.

Contrary to the 'keys' utility built into MicroKernel DOS, 'sake' can be loaded into memory and exited without disturbing your SuperBASIC program (depending on length and complexity).  Longer term, I have a goal to convert this into a fully relative (loadable at any location in memory) application.  If you have a desire for a different load address or would like a .PGX or specific MMU pre-load, please contact me.

Documentation on the preliminary release of MIDI Retro-scope for Foenix F256 computers.

If you've not seen it, there is a YouTube video on the subject that can be accessed here: https://youtu.be/s9_o_lt4mK8

Foenix Rising Flash Issue #16 is an 9-page article discussing MIDI, and two DIY projects for your legacy F256 platform.  THIS DRAFT is 6 pages, and is due to be updated shortly.

Discussion on the content or notes on corrections or suggestions can be conveyed on the Foenix Discord in the "emwhite" channel.

A collection of > 50 General MIDI files (.mid extension), playable on systems as old as ATARI 800's MIDIPLAY.XEX and as recent as the newest versions of Apple Garage Band as bundled with Apple OSX (as of Ventura, at the time of this posting).

Reference a YouTube playlist on the topic (currently in development) and associated content on my YouTube channel:

https://www.youtube.com/@8-bitwallofdoom

Foenix Rising Flash Issue #15 is an 8-page article recapping some of the happenings from VCF East 2024, held this April in Wall Township, NJ

In addition to introducing the event, FOUR threads of Vintage are covered:

1. ATARI Classroom overview - details of this year's installation, which weighed heavily on FujiNet.

2. Consignment Assignment - a fun feature about a popular attraction and pastime and how I got sucked into the vortex, and loved it.

3. Conversation with BurgerBecky - about software development, and in particular, aspects of her "Racing Destruction Set" port.  In the mid-80s, she created an ATARI 400/800 version from the Commodore 64 original for Electronic Arts.

4. Home Computer Museum - a one-pager about a privately owned and run museum that looks amazing and is now officially on my travel list.

Foenix Rising Flash Issue #F14 is an 7-page article focused on keyboard input and the methodology and code required to handle interrupts and queues.

Specifically, we are talking about the PS/2 protocol and considerations for managing it in 6502 assembly language.

The spoiler here is that this article was actually started over a year ago and has sat frozen in time while I pursued other endeavors (#1 of which was getting healthy enough to sit in a chair and write).

As always, this is but one episode of a continuing conversation with flashbacks to prior issues and forward thinking to what will come next (or eventually, I hope).

We close with a few relevant links to videos from one of my favorite YouTube channels.  If you don't already know, you'll soon be reminded. 

Where do we start?  At the beginning, the typewriter; with another wrenching tale from my childhood.  Regardless of your age, experience, or background, I implore you to watch Chyrosran22's IBM Selectric video, linked on page 1.  I guarantee satisfaction.

I am excited to announce the pending release of a SID focused utility program for the F256 platform.

SIDlab is a playground for "what-if" sound design.

This document represents the final feature-list for beta 2.  This version has a number of additional features (absent in the PoC) but closer to the intended GA release, than initially thought possible.  The attached document and particularly, page 5-8, outline these features.

SIDlab will shortly be available as a .PGX download here, or for those with F256 equipped feather WiFi, magically over-the-air. 

Song data for the SID player embedded in the F256 Christmas demo (foenixmas23).

See this YouTube playlist for full context: 

https://www.youtube.com/watch?v=DA-xJmeTnAo&list=PLeHjTvk7NPiTtBKQYAeS-sqzXNzc0dXMN

Foenix Rising presents the Commodore Christmas demo from 1982. (well, the soundtrack from it). 

Painstakingly extracted and ported with a custom developed SID player and a season appropriate Holiday scene, a SuperBASIC loader BLOADs the graphic assets and 18K assembly language program, containing the binary song data for all 7 Commodore Christmas songs.

It's not perfect, but this is the result of 4 days of intense archeology, discovery and coding.

In this spirit of the original demo, the BASIC program gets the job done, passing control off to an Assembly language application, developed using F256 MicroKernel event services.  The graphics were prepared with thanks to Ernesto Contreras's BMP converter code and tutorial published in issue #13.

To run, unzip onto an SD card, confirm that all four files are present with a 'dir' on your F256 while in SuperBASIC, load the program "foenixmas23.bas"; and type RUN.

This version only supports a single SID in the left socket (on a Jr.); depending on your CODEC settings, it may only play out of the left channel.

We will expand on this in a future issue of Foenix Rising.

Happy Holidays to all and to all, a good night (posted at 11:30pm on Christmas Eve)

(feel free to reach out to me directly or on Discord with any issues or question; I had no time to test this with others : )

Foenix Rising Issue #13-Full is a 25-page journal and represents the first FULL issue since December of 2022.

We will return to our Flash format in January as development and technical discussions continue.

2024 represents the start of our 3rd year publishing this Newsletter and I've enjoyed it, learned alot, and made some great friends in the Foenix community.

This issue is packed with the usual amount of new & retro nostalgia, and technical detail, and primarily features two major articles:

• An interview with Boisy Pitre, Developer of NitrOS-9 for the F256 and FNX6809 CPU in addition to other relevant and interesting work
• A graphically oriented article authored/contributed by Ernesto Contreras; includes a SuperBASIC program that you can leverage to convert existing .BMP files for use in your own programs.  It's part retrospective and part tutorial.

Also, a republish and update to the MicroKernel DOS and event use article, an update on nanoEdit, a feature on the Commodore Christmas Demo, and more.

Files relevant to this issue include Ernesto's SuperBASIC program and also, the SAK (stand-alone-keys) .zip file which is posted below issue #F12.  The FoeniXmas23 demo will be posted this week (pushing to finish it today but... you know... family/Christmas : )

Our regularly scheduled nanoEdit development project will return in January of 2024.

A .BMP converter which can take indexed palette images saved from Open Source graphic editing tools such as GIMP (free) and remove the Palette for use within a Foenix F256 SuperBASIC program.

See the 8 page article in Issue #13 of Foenix Rising (above)

This program, and Ernesto's expertise was helpful in developing the FoeniXmas23 demo. (to be linked above this week).

NOTE: This article has been updated and included within our year-end issue (Issue #13 above); please download that copy instead.

-----

Foenix Rising Flash Issue #F12 is an 8-page article (including the cover page) and is an EARLY RELEASE.

Intended to be part of an end-of-year FULL issue of Foenix Rising (in classic format), I'm opting to release it early.

You'll note two or three references which are unresolved (in red); this will be fixed in the full issue, scheduled to be released on December 24th.

Have a look for the accompanying .zip file containing the source, .lst, and PGX binary.

Our regularly scheduled nanoEdit development project will return in January of 2024.

NOTE: This article has been updated and included within our year-end issue (Issue #13 above); please download that copy instead.

-----

Foenix Rising Flash Issue #F12 - "Supplement" is a single page add-on to the prior article; it discusses additional information and some retro details on binary header files including some tricks and resources to round-out your use of SuperBASIC binary file loading with programming examples included from the F256 Graphics Toolkit by Ernesto Contreras (which can be downloaded from this site).

This one-pager and the prior article is intended to be part of an end-of-year FULL issue of Foenix Rising (in classic format), I'm opting to release it early.

Two or three references in the original article above, are unresolved (in red); this will be fixed in the full issue, scheduled to be released on December 24th.

Have a look for the accompanying .zip file containing the source, .lst, and PGX binary.

Our regularly scheduled nanoEdit development project will return in January of 2024.

zip file to accompany Foenix Rising Issue #12

Includes:

standalonekeys.asm, sak.lst (the 64tass output), sak.pgx (executable), and not discussed, but an autostart binary which should be loaded via the F256 Uploader into block 10:0000 (assuming extended RAM present).  After pushing this file into your machine, it may be necessary to reset.

The .pgx file is loadable and runable either from SuperBASIC or from DOS as discussed in the accompanying article.

The other two files are clear ascii text.

Here is a suitable Makefile (however, it will always create a .bin regardless of header)

------

always: standalonekeys.bin

COPT = -I . -C -Wall -Wno-shadow -x --verbose-list

APP = \

standalonekeys.asm \

api.asm \

standalonekeys.bin: Makefile $(APP) 

%.bin:

64tass $(COPT) $(filter %.asm, $^) -b -L $(basename $@).lst -o $@ 

Foenix Rising Flash Issue #F11 is an 11-page article focused on nanoEdit which was derived from Compute Publication's SpeedScript.

This issue touches on a number of user interface features and then takes a fair look at the VICKY FPGA Math Block 16-bit division function.

We also take a quick stop to talk about something Wozniak did (in 1976) but otherwise, it's all Foenix and all F256.

As prior, this can be considered part 3 of the n part series.  And as prior, we promise to publish code to a github repo, once stable (closer to the end of this year).

Somebody challenged me to port the Commodore Christmas demo to the F256 and I'm thinking about it.  If I take the work on, the next issue of this newsletter will be someway delayed.  I hope you understand.

Foenix Rising Flash Issue #F10 is a 6-page article focused on our effort to port Compute Publication's SpeedScript to the F256 platform for use within our nanoCLI environment and potentially, for native MicroKernel (present on every F256K and F256 Jr.)

This issue also contains 5 pages of re-print content; one page from our first issue that details a very very bad example of how to number lines in BASIC (thank you Commodore!); and four pages from our 2nd issue, pertinent to the history of COMPUTE. magazine.

As always, we revisit the days-of-old and discuss internals, theory of operation, and some code.

This can be considered part 2 of the n part series.  And as prior, we promise to publish code to a github repo, once stable (closer to the end of this year).

Foenix Rising Flash Issue #F9 is a 7-page article focused on a previously mysterious and particularly elusive tool; the Machine Language Monitor.

We explore a modest amount of history then discuss the beginnings of a ML Monitor for the Foenix F256.

Tons of links including a few videos, and plenty of vintage lore inside.

This is part 1 of an n part series.  Code will follow as the project grows legs, closer to the end of this year.

This 'toolkit' is composed of a single zip file which contains 3  [otherwise] stand-alone applications tied together with "menu.bas" as follows:

• Sprite Editor
• Tilemap Editor
• Font Editor

The .zip must be unzipped on your PC or Mac where you can move the files over to an SD card, then sneaker-net to your Foenix system (either F256K or F256 Jr.).   This zip file contains "menu.bas" which is the front end, pictured above, each of the 3 apps, supporting files and documentation.

NOTE: Depending on which version you have installed previously, you may or may not have a font image file (see the "bold.font" file immediately following this in the date sorted listing).  Simply download this file as well, and place it on the SD along with the rest of the files.

See above listing; this file is required to be in the same directory and must be unzipped on your pc, mac or linux machine.

Foenix Rising Flash #2 (released as Issue #6) is an 6-page article focused on converting BCD values to sprite pointers, load assets, instantiating sprites, the RTC (real-time-clock), and interrupts.

In this issue, we further explore some of the Bouncing ball demo discussed last month and create a variation which displays a time of day clock on the screen leveraging a similar sprite set to what was used last month.  There is a bit of visual effect thrown in/on-top, and a single counter representing screen draws which are running as fast as the machine is able.  The time-of-day clock, however, is being rendered by an IRQ interrupt strapped to a 500 ms. trigger.

The graphic set which is composed of 11 sprites of 32 pixel x 32 pixel from last issue has been expanded (16 sprites now) to include a handful of special symbols, the most important of which is the ':' (colon character), used between sets of digits in the clock.

A fully commented source, binary, and graphic asset .zip file will be posted shortly.

(this issue focused on the F256 Jr., also applicable to the soon-to-be-released F256K, but many of the concepts apply to other Foenix machines with VICKY family FPGA engines in addition to the RTC circuit.)

See above; contains .asm source code, assembled .bin, Makefile, and sprite assets for the Issue 6 Project

Foenix Rising Flash #1 (released as Issue #5) is an 8-page article focused on the F256 Memory Management Unit (MMU) and bitmapped graphics in addition to sprites.

In this issue, we port a 6502 based Bouncing ball demo originally written for the Apple II by Stephen Edwards.

The MVP and limited telemetry release of the program is posted below and will be followed up with full source code and new features as we explore additional capabilities of the F256 (Jr. and 'K') platforms.

The subject of Foenix Rising Flash #5, this assembled binary will need to be pushed in via USB debug port and booted from RAM @ $8000

This no-kernel, bouncing PONG ball demo was adapted from Stephen Edwards "balls" demo for the Apple II which was produced and introduced via this YouTube video for VCF (the Vintage Compute Federation): https://youtu.be/WEliEAc3ZyA

The Foenix F256 version of this program is configured with 48 bouncing balls.

Consult the accompanying article and look for the telemetry version in addition to other assets.

The source for this program will be posted in the next 2-4 weeks, or upon request (contact me via Foenix Marketplace links)

The subject of Foenix Rising Flash #5, this assembled binary will need to be pushed in via USB debug port and booted from RAM @ $8000

This no-kernel, bouncing PONG ball demo was adapted from Stephen Edwards "balls" demo for the Apple II which was produced and introduced via this YouTube video for VCF (the Vintage Compute Federation): https://youtu.be/WEliEAc3ZyA

The Foenix F256 version of this program is configured with 32 bouncing balls and includes telemetry (on screen counters representing memory fetches)

Consult the accompanying article and look for the standard version in addition to other assets.

The source for this program will be posted in the next 2-4 weeks, or upon request (contact me via Foenix Marketplace links)

.dat file, contains 11 sprites for the balls telemetry example; leveraged in Foenix Rising Flash #5

(see accompanying article, assets, and assembled code)

.xls file, used to calculate table offsets and bank numbers; leveraged in Foenix Rising Flash #5

(see accompanying article, assets, and assembled code)

This 400+ line assembly language source assembles via 64TASS via included "Makefile"; also includes character set and the .bin file which is available separately directly beneath this file.

(see the item below for full description)

This assembled binary will need to be pushed in via USB debug port and booted from RAM @ $E000

This no-kernel, medium budget string output routine prints text centered on an 80 x 60 screen in a variety of colors then halts.

Issue #4, pg. 19 onwards describes the algorithm and data structures leveraged in tutorial fashion.

Source code, "Makefile', character set, and [this] .bin file are available in I04P19A.zip file above.

This demo is a partially playable version of the famous video game developed by a hobbyist as an academic exercise.

With the Z80 source available online, many have undertaken projects to learn from, and to port games of this type to numerous platforms.

NOTE: this file is in .hex format and must be pushed into a debug port using the IDE or a related utility.

This version supports the the c256U/U+, the FMX, and the soon to be released GenX.

This is the latest revision of the full 26-page copy of Issue #4 of Foenix Rising published on December 31st, 2022.

Please see the errata (button on home page above) for description of change/fixes.

Thank you!

A take on Dr. Marvin L. De Jong's Mersenne Prime example as discussed in Issue #4 of Foenix Rising, pgs. 10-16.

Note that this is a 6502 assembled (binary) object file that must be pushed into a Jr. through the USB debug port.

Further, unlike the C256 Jr., the F256 Jr. has an onboard jumper (@J3) which dictates 'boot mode' for either Flash (default, the left position) or RAM (the right position).  In order to make this code run, you will need to boot from RAM, and push this code into your machine with a load address of $E000.

Any issues, ping me.

About this code: over the course of 2-3 minutes, you'll witness [extremely large] number generation (in the upper 1/2 of the screen), followed by decimal display of the 1963 largest known prime number (a few thousand digits in length).

This program does not accept any input and leverages a 'no-kernel' model, which is to say that it is a self-contained binary that initializes the Jr. hardware and VICKY FPGA, then executes via RESET vector.

In future, a load ready binary will be developed and provided, which will take .bin files from SD card and load into memory for execution without the need for (J3) jumper strapping.

As discussed in issue #4, pg. 25 of Foenix Rising, this is the full source of 128 characters for a VT100 style font.

You may need to tweak the format depending on which assembler you are using.

Please provide feedback so we can amend this description for others.

This is the full 32-page copy of Issue #3 of Foenix Rising published on October 16th, 2022.

A high resolution copy of page 17, the puzzle.

Useful in trying to solve, or fun just to look at.

Finished Foenix Balloon Program from Issue #3

Use with FBALLOON5.SPR and SPREDTV1.PAL after the req'd setup noted on page 28

See pages 24 -  28 for details.

This BASIC816 program accompanies the RTC (real-time-clock) article published in the September/October (issue #3) of Foenix Rising.

See pgs. 18 - 20

Foenix Sprite Editor v1 .PAL file

.PAL files contain a full 256 color RGB representation in load-ready format.

This particular .PAL file is required for the Foenix Balloon program published in Issue #3 of Foenix Rising on page 27 but may be used with any Sprite developed using v1.0 of the Foenix Sprite Editor.

See pg. 21 - 28 of issue #3 for details.

A 12 Sprite .SPR file featuring 1 stationary (descending) Sprite, 5 'landing' animated Sprites, and 6 ascending (flame cycling) Sprites.

In total, this = 12,289 bytes or 12 x 1024 + 1 byte as 'count' at the head of the file.

This Sprite was featured in the 3rd instance of "Beginner's Corner" in Foenix Rising, which was published in mid-October.

Update to the Foenix Sprite Editor released in 2021

Improved color manipulation tooling and bug fixes since the prior version

See Foenix Rising #3 for a detailed look at this update

The .ZIP file contains documentation for this release

This is the full 32-page copy of Issue #2 of Foenix Rising published on August 26th, 2022.

Foenix Balloon "2" (1K binary file) for use in the "Beginner's Corner" BASIC816 Programming example located in the August 2022 issue of the Foenix Rising Newsletter.  This (.SPR) format is load/modify-ready with Ernesto's "Foenix Sprite Editor", or your own programs.

LUT Load pagination utility as discussed on pg. 21 and pg. 22 of Issue #2

This BASIC program is a standalone program that:

1. Loads LUT 0 with a full palette as discussed previously
2. Dumps 8 pages of formatted values representing each RBG color with hex and decimal values

Dump Spr(ite) utility as discussed on pg. 22 of Issue #2

This BASIC program is a standalone program that:

• Interprets the Sprite data resident @ &h100000, dumping LUT values to the screen
• Artificially depicts ' . ' when a transparent (LUT value $00) is encountered

Diagonal Sprite example discussed on pg. 23 of Issue #2

This partial example requires execution of any of the 'full' examples from Issue #1, or instantiation of a color LUT load (example "I01P11A.BAS") followed by BLOAD of "FBALLOO2.SPR" and MEMCOPY to VRAM followed by a SPRITE, SPRITEAT and SPRITESHOW.  (you can do it!)

The program navigates the Foenix Balloon (or any Sprite defined at Sprite 0) diagonally around the four edges of the screen while cycling color $4A between a dark red and a dark green.  The example as discussed in the accompanying article sets the stage for Balloon 'flame' animation, which we will pick up on next issue.

Microsoft Windows based Foenix C256 Integrated Development Environment

Developed by Daniel Tremblay, this 'off-host' development and debugging environment includes a set of tools for moving data to and from C256 based Foenix platforms.

Changes in this version:

Added tool to generate PGZ files.
Updated the Uploader Dialog to allow for sending PGX and PGZ files.
Updated IDE start-up to accept PGX and PGZ files - from "Load Executable menu" and drag-n-drop.

Git repo here: https://github.com/Trinity-11/FoenixIDE/releases/tag/release-0.5.6.8

A BASIC816 based Sprite Editor for the C256U and C256U+ platform (leveraged in the Foenix Rising Newsletter "Beginner's Corner")

Written in BASIC with machine language subroutines by Ernesto Contreras; the editor provides a full color palette and editing tools for full size (32 x 32 pixel) multi-color Sprites that can be saved into stand-alone or multi-sprite (up to 255) files for use within your own BASIC or machine language programs and utilities.

Be sure to download the .pdf documentation which should appear beside this .zip file in the Foenix Marketplace.

To use, unzip in a directory, move to SD card, insert into your Foenix, and then type LOAD "SPREDIT.BAS" <enter> and when the cursor comes back after loading, type "RUN".

https://github.com/econtrerasd/Foenix-Sprite-Editor

The 10-page instruction manual for the Foenix Sprite Editor.

This is a full 18-page copy (including the 2 page vintage insert) of the inaugural issue of Foenix Rising published on July 10th, 2022.

This is an 15-page grey scale and reduced quality rendering of the inaugural issue of Foenix Rising published on July 10th, 2022 absent the A2560K Photo Feature.  This version of the newsletter is better for printing if using an ink jet printer;  also ideal for those among us that 'read it for the articles'.  For the full issue with higher quality pictures, look for "(full)".

NOTE: The inline pictures are present but are not very clear due to Quartz filtering.

This is the 5-page A2560K Photo feature output with high quality images from the inaugural issue of Foenix Rising published on July 10th, 2022.

Foenix Ballon (1K binary file) for use in the "Beginner's Corner" BASIC816 Programming examples located in the July 2022 issue of Foenix Rising.  After unzipping, this (.SPR) format will be load/modify-ready with Ernesto Contreras'es "Foenix Sprite Editor", or your own programs.

Jet Sample Sprite (1K binary file after unzipping) for use along with the examples in the "Beginner's Corner" BASIC816 Programming article located in the July 2022 issue of Foenix Rising.  After unzipping, this (.SPR) format will be load/modify-ready with Ernesto Contreras'es "Foenix Sprite Editor" or your own program.

'Yellow Square' Sprite example, discussed on pg. 9

This 6-line BASIC816 code defines and positions a Sprite on an otherwise blank screen.

Color look-up-table discussed on pg. 11

This BASIC816 subroutine (meant to be called with a GOSUB) creates palette/LUT #0, loading 768 values (256 x 3).

Pay particular attention to the comments on lines 10000 - 10015 and modify if stand-alone is desired.

NOTE that this LUT may be used for Tiles / Bitmaps; to be discussed in future issues.

Stationary Sprite example discussed on pg. 11

This 'full program' includes the BASIC816 load LUT subroutine from example 'a', and creates a stationary Foenix Balloon @ coordinates 100, 100.  NOTE that there is a dependency on "FBALLOON.SPR" to be present in the working directory.

1st moving Sprite example discussed on pg. 11 - "x-axis"

This 'full program' includes the BASIC816 load LUT subroutine from example 'a', and creates a Foenix Balloon, moving it from coordinates 0, 0 to 200, 0 in an endless loop.  Press the 'break' key to break out of the loop.  Things to try: change the coordinates and loop boundaries; add a delay "for / next" loop within the x% loop in order to slow down the movement.

2nd moving Sprite example discussed on pg. 11 (similar to example 'c', however it increments the y-axis instead of the x-axis for vertical movement)

This 'full program' includes the BASIC816 load LUT subroutine from example 'a', and creates a Foenix Balloon, moving it from coordinates 0, 0 to 0, 200 in an endless loop.  Press the 'break' key to break out of the loop.  Things to try: change the coordinates and loop boundaries; add a delay "for / next" loop within the y% loop in order to slow down the movement.

3rd moving Sprite example - discussed on pg. 12 (similar to examples 'c' and 'd', however it increments the x-axis and y-axis at the same time based on n%, yielding ~45' (to horizontal) movement.

This 'full program' includes the BASIC816 load LUT subroutine from example 'a', and creates a Foenix Balloon, moving it from coordinates 0, 0 to 200, 200 in an endless loop.  Press the 'break' key to break out of the loop.  Things to try: change the coordinates and loop boundaries; add additional sprites based on the same bitmap and an offset color palette; add a delay "for / next" loop within the n% loop in order to slow down the movement.

4th moving Sprite example - discussed on pg. 12 (similar to example 'a', however, increments the x-axis twice per every one y-axis update resulting in a slightly less steep diagonal movement).

This 'full program' includes the BASIC816 load-LUT subroutine from example 'a' from pg. 11, and creates a Foenix Balloon, moving it from coordinates 0, 0 to 200, ~100 in an endless loop.  Press the 'break' key to break out of the loop.  Things to try: modify the formula in order to send the ballon on an alternate path using more complex math, trigonometric, or keyboard controlled functions or maybe..., write a mini-game, accepting text commands and using if / then conditionals to move n # of pixels in a particular direction in order to arrive at a given, random point on the screen in a minimum of 'moves'.

The BASIC816 Language Manual (16 pages)

Contains important and useful details about the interpreter including C256 specific statements for graphics, PGX file format, DOS commands, PEEK, POKE, and MEMCOPY.

https://github.com/pweingar/BASIC816

BASIC816 Quick Reference Sheet (2 pages)

The famous Frogger - this is more difficult than I remember !!

IMPORTANT NOTE: This .HEX for the C256U/U+ ONLY; the FMX binary (PGZ) is posted as well.

https://github.com/dtremblay/fraggy

The famous Frogger - this is more difficult than I remember !!

IMPORTANT NOTE: This binary is for the FMX version ONLY; look for the C256/U or U+ version, available in .hex format.

https://github.com/dtremblay/fraggy

The famous Tetris game, no introduction needed.

IMPORTANT NOTE: This .HEX for the C256U/U+ ONLY; the FMX binary (PGZ) is posted as well.

https://github.com/dtremblay/c256-tetris

The famous Tetris game, no introduction needed.

IMPORTANT NOTE: This binary is for the FMX version ONLY; look for the C256/U U+ version, available in .hex format.

https://github.com/dtremblay/c256-tetris

MCP Kernel documentation for the v1.0 Kernel

Github repo: https://github.com/pweingar/FoenixMCP

Minesweeper Clone, written as a proof of concept in TRSE (Turbo Rascal Syntax Error)

For more information on TRSE: https://lemonspawn.com/turbo-rascal-syntax-error-expected-but-begin/

Pong, the classic.

This proof-of-concept is playable and has low-budget, period accurate (it seems) PSG based sounds.

Some of the source can be found in this public repo: https://github.com/thezerobit/foenix_defs

This BASIC816 program represents the beginnings of a famous 'bug' shoot-em'-up game.  Ok ok, it's Centipedes.

In addition to the BASIC code, which can be learned from, you will find "BUGS13.SPR" which contains expertly rendered Sprites (over 30) from the classic game.  The Sprite file is editable with Ernesto's Foenix Sprite Editor, available in this Foenix Marketplace.

This is 'NOT_RELEASED', simply meaning that it is not finished and is being offered for educational purposes.

Halloween Invaders - Shoot-em'-up Game

Knock out monsters with your stash of candy on Halloween night before they reach you!  Dodge the blobs of slime or take shelter under the trees before they are disintegrated by the monster slime.

Play on your own or up to 4 players on the C256 Foenix FMX or U/U+.

This is an early demo of a C language line draw routine which is being developed as part of a graphics library for the Calypsi C compiler.

Load this with a BRUN "GRDEMO.PGZ".  Upon exit back to BASIC816, you will need to blindly issue a "GRAPHICS 39" command (or a suitable alternative).

Match It! - Puzzle / Action game

Match 3 or more tiles horizontally or vertically along or head-to-head.

Collect bonus points for chain reactions.

For 1 or 2 players on the C256 Foenix FMX or U/U+.