Skip to content

Home

Jump to bottom
Bill Lange edited this page Mar 1, 2024 · 104 revisions

Action History

  • Action IDE (Integrated Development Environment) cartridge released for sale in 1983
  • Optional disk-based Action Toolkit was released to add additional library of functions and procedures
  • Optional disk-based Action Runtime Package released to allow stand-alone programs to be created
  • At least three commercially released programs created in Action (HomePak, Games Computers Play, Star Fleet)
  • Dozens of magazine-published articles and games released
  • Action source code released to public in 2015
  • Updated Action language released soon after to address some issues

Pros

  • Editor, compiler, and runtime library all built into cartridge
  • C and/or Pascal like language
  • Executed much faster than BASIC
  • Much easier to learn than Assembly language

Cons

  • Expensive (Action cartridge, Action Took Kit, Action Runtime Package, License)
  • Released relatively late in the life of the Atari 8-bit
  • Editor, compiler, and runtime library all built into cartridge so expensive cartridge was required to run programs

Development Environment

  • Lastest version of the Altirra (version 4.20) Atari 8-bit emulator running on a Windows laptop
  • Lastest version of the Action programming language (version 3.7 post 2015 public release update)
  • Github
  • Fujinet equipped Atari 8-bit

I typically write my Action source code in Github, trying to avoid using any undisplayable ATASCII characters directly, then copy and paste my source code into the Action editor in the Altirra emulator to compile, run, and test. I also write code in the Action editor in Altirra, then "write" it to Altirra's "Printer Output" window. From Altirra's "Printer Output" window, I copy and paste the source code into Github.

I use the TNFS server software and a Fujinet to deploy the code to a physical Atari 8-bit for further testing.

Useful Action IDE Commands

Location Atari Keyboard Command Altirra/PC Keyboard Command Result
Editor SHIFT+CLEAR SHIFT+Home Clear the buffer
Editor CONTROL+INSERT Insert Insert a character
Editor CONTROL+DELETE Delete Delete a character
Editor SHIFT+INSERT SHIFT+INSERT Insert a line
Editor SHIFT+DELETE SHIFT+DELETE Delete a line
Editor SHIFT+CONTROL+W SHIFT+CONTROL+W Write source code to disk, cassette, printer, etc.
Editor SHIFT+CONTROL+R SHIFT+CONTROL+R Read source code from disk, cassette, etc.
Editor SHIFT+CONTROL+M SHIFT+CONTROL+M Go to the Monitor
Monitor E E Go to editor
Monitor C C Compile
Monitor R R Run/execute
Monitor DOS DOS Exit to DOS

A First Program

When the Atari 8-bit is booted with the Action Programming Language cartridge installed, it initially boots to the Action Editor.

Enter the following program in the Action Editor:

; HELLO
; In the Action Programming Language

CHAR ARRAY N(30) ; Global variable

PROC GETNAME()
 PRINTE("ENTER YOUR NAME: ")
 INPUTS(N)
RETURN

PROC WAIT()
 BYTE K ; Local variable
 PRINT("PRESS ANY KEY TO EXIT")
 CLOSE(1)
 OPEN(1,"K:",4,0)
 K=GETD(1)
 CLOSE(1)
RETURN
 
proc hellogr2()
; Action source code is case insensitive
; Best to stick to one style

 graphics(2)
 printd(6,"HELLO ")
 printde(6,N)

return

PROC MAIN()
; Last procedure in the program in the entry point when program is run
; Doesn't have to be called MAIN

; Procedure calls
 GETNAME() 
 HELLOGR2()
 WAIT()

RETURN

From the Action Editor, enter SHIFT+CONTROL+M on the Atari keyboard to enter the Action Monitor. The Action Monitor is like the switchboard of the Action IDE. It lets you switch between the Editor, the Compiler, the Execution environment, Debugging, and DOS (Disk Operating System).

From the Action Monitor, enter C [RETURN] to compile the source code.

From the Action Monitor, enter R [RETURN] to run the compiled program.

image

When prompted, enter a name, then press RETURN. Toggle between upper and lower case characters to change colors.

Press any key to exit the program.

From the Action Monitor, enter E [RETURN] to return to the Action Editor.

Key Takeaways

  • Action source code is case-insensitive
  • Comments begin with a semicolon
  • Comments can be on their own line or at the end of a line of code
  • The last procedure in an Action program is the entry point
  • The entry point procedure can have any name, but suggest to use MAIN or the filename of the program as stored on disk

Data Types

The Action programming language supports three fundamental Data Types:

  • BYTE - A BYTE type can be any unsigned (positive) integer between 0 and 255 (one-byte). BYTEs are useful for loop counters and handling characters. You can use BYTE and CHAR interchangeably.
  • CARD - A CARD (known as a cardinal) type can be any unsigned (postive) integer between 0 and 65,535 (two-bytes).
  • INT - A INT (known as a integer) type can be any signed integer between -32,768 to 32,767 (two-bytes).

All three fundamental Data Types are numeric integers.

While there are no real number Data Types built into the Action language cartrdige, a REAL Data Type is included in the optional Action Toolkit that provides access to the Atari's built-in floating point package.

Variables: Declaring, Displaying, And Entering

PROC MAIN()  

BYTE A; UNINITIALIZED  
BYTE B=[100]; INITIALIZED TO 100  
BYTE COLOR2=710; POINT TO COLOR2 ADDRESS 

A=0  

PRINTE("BYTES")  
PRINTE("")  

PRINT("A=")  
PRINTBE(A)  

PRINT("B=")  
PRINTBE(B)  

PRINT("COLOR2=")  
PRINTBE(COLOR2)  

COLOR2=255 ; Change background color

PRINTE("")  
PRINT("ENTER A BYTE:")  
A=INPUTB()  
PRINTBE(A)  

COLOR2=148 ; Change background color back

RETURN

Print Procedures

The various PRINT procedures start with the word PRINT and may include decorations. There are three groups of decorations. The first decoration is for the type of data that will be printed. The second decoration is used if printing to a device (graphics screen, disk, etc.). The third decoration is used to include an end of line. If the end of line decoration is used, the cursor will be moved to the beginning of the next line after the printing operation. If not, the cursor stays on the current line.

PRINT[B|C|I][D][E](...)

If you are printing a string constant and want the cursor to stay on the same line, the word PRINT is all you need.

PRINT("THIS IS A STRING CONSTANT")

When printing varialbes, you must use one of the 'B', 'C', or 'I' decorations to print a BYTE, CARD, or INT value.

BYTE aByte=[100]
CARD aCard=[1000]
INT aInt=[-100]

PRINTB(aByte)
PRINTC(aCard)
PRINTI(aInit)

Input Functions
x=INPUT[B|C|I][D]()

Decoration Meaning

  • B = BYTE
  • C = CARD
  • I = INT
  • D = Device
  • E = EOL/CR

Operators

Decisions

Looping

More Information

https://www.virtualdub.org/altirra.html
https://atariwiki.org/wiki/Wiki.jsp?page=Action
https://www.youtube.com/@davidarlington1206
https://archive.org/details/ataribooks-mapping-the-atari

Clone this wiki locally