Visual batari Basic

https://www.randomterrain.com/atari-2600-memories/
Admin
Visual batari Basic (VbB) is an Integrated Development Environment (IDE) designed to make creating...
Tokens:101,239
Snippets:570
Trust Score:9.4
Update:1 year ago
Show doc for...
Tokens:
Raw
### Basic Sprite and Paddle Setup Example

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Initializes sprite vertical positions, defines player sprites, and sets player0 color and size for a typical Atari 2600 game loop.

```batari Basic
set kernel_options no_blank_lines readpaddle


;***************************************************************
;
;  Sets sprite locations.
;
player0y = 12 : player1y = 85


;***************************************************************
;
;  Creates paddles.
;
player0:
%1111111
%1111111
end

player1:
%1111111
%1111111
end



__Main_Loop



   ;***************************************************************
;
;  Sets up color and size of player0 (double size).
;
COLUP0 = $9C : NUSIZ0 = $05
```

--------------------------------

### Binary Number Notation Examples

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-04

Provides examples of decimal and binary number notations, emphasizing the use of the '%' prefix to denote binary numbers. This clarifies how to distinguish between the two systems in written form.

```text
123 is decimal and %1111011 is its binary equivalent.

101 is decimal
%101 is binary = 4 + 1 = Five
```

--------------------------------

### Binary Subtraction Example 1

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-05

Illustrates binary subtraction using the same values as the decimal example. Details each step, including subtractions and borrows, to arrive at the correct binary result.

```ascii
     %1111100 (= 124 decimal)
   - %1110011 (= 115 decimal)
     --------
      |||||||
      |||||||
      ||||||+---> 0 - 1     = 1 with borrow of 2 --------+
      ||||||                                   |          |
      ||||||              +------ borrow ------+          |
      ||||||              v                               |
      |||||+----> 0 - 1 - 1 = 0 with borrow of 2 --------+| 
      |||||                                    |         ||
      |||||               +------ borrow ------+         ||
      |||||               v                              ||
      ||||+-----> 1 - 0 - 1 = 0 ------------------------+|| 
      ||||                    |                         |||
      ||||                +---+  no borrow              |||
      ||||                v                             |||
      |||+------> 1 - 0 - 0 = 1 -----------------------+|||
      |||                     |                        ||||
      |||                 +---+  no borrow             ||||
      |||                 v                            ||||
      ||+-------> 1 - 1 - 0 = 0 ----------------------+||||
      ||                      |                       |||||
      ||                  +---+  no borrow            |||||
      ||                  v                           |||||
      |+--------> 1 - 1 - 0 = 0 ---------------------+|||||
      |                       |                      ||||||
      |                   +---+  no borrow           ||||||
      |                   v                          ||||||
      +---------> 1 - 1 - 0 = 0 --------------------+||||||
                              |                     |||||||
                              v                     vvvvvvv
                              no borrow            %0001001 = 9 decimal = final answer
```

--------------------------------

### Defender DEY-BNE Loop Example - Atari 2600 Assembly

Source: https://www.randomterrain.com/atari-2600-memories/-guide-to-cycle-counting

This assembly code snippet from the game Defender demonstrates the DEY-BNE loop used for timing. It initializes variables, sets up colors, and then enters the loop to create a delay. The comments indicate cycle counts for each instruction, crucial for understanding the loop's execution time.

```assembly
       STA    WSYNC   ;               Cycle count:
       STA    PF2     ;Clear PF2       [0]  +3
       LDA    $EA     ;                [3]  +3
       STA    COLUP0  ;                [6]  +3
       STA    COLUP1  ;                [9]  +3
       LDY    #$08    ;                [12] +2  Y is set here
       STA    RESP0   ;                *14* +3
LF867: DEY            ;When 8 (17), when 0 (52)  }
       BNE    LF867   ;At end of loop, (54)      } +39
       STA    RESP1   ;                *56* +3

```

--------------------------------

### State Machine: Simple Light Switch Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-07

Defines the states, inputs, and transition table for a simplified model of a light switch. This example demonstrates the core components of a state machine: current states (LIGHT_ON, LIGHT_OFF), possible inputs (SWITCH_UP, SWITCH_DOWN), and how inputs dictate the next state.

```plaintext
Lists of States: ( LIGHT_ON , LIGHT_OFF )
List of Inputs:  ( SWITCH_UP, SWITCH_DOWN )
Table of Transitions:
                      | Input:
   current state:     | SWITCH_UP   | SWITCH_DOWN
                      +-------------+-------------+
          LIGHT_ON    | LIGHT_ON    | LIGHT_OFF   <<== The cells of the table 
                ------+-------------+-------------     contain the next state.
          LIGHT_OFF   | LIGHT_ON    | LIGHT_OFF
```

--------------------------------

### Score and Game Initialization Example

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This comprehensive example sets up game elements including ball position, score, and colors. It initializes `ballx`, `bally`, and `ballheight`. It also sets the initial `score` and `scorecolor`, and activates specific control bits for reset functionality.

```assembly
;***************************************************************
;    Move cursor left/right with joystick to select score digit.
;    Press up to add to the digit or down to subtract from it.
;
;***************************************************************

dim _Bit0_Reset_Restrainer = y
dim _Bit1_Joy0_Restrainer = y
dim _sc1 = score
dim _sc2 = score+1
dim _sc3 = score+2


__Start_Restart

   ; Sets ball cursor position and height.
   ballx = 64
   bally = 87
   ballheight = 0

   ; Sets score and score color.
   score = 123456
   scorecolor = $1A

   ; Makes reset inactive if held.
   _Bit0_Reset_Restrainer{0} = 1

```

--------------------------------

### Binary Addition Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-05

Illustrates the process of binary addition with carries, similar to decimal addition. Shows how a carry can form a new leading digit. This example uses ASCII art to represent the calculation.

```ascii
+------- 1+1 +  1 = %11 ----------------+
                         |
                         +-- Carry the 2 --+
                                           
                                           vvvvvvvv 
                                          %11101010 = 234 decimal = Final answer
                                           |
                                           v
                                           Please note that the final carry forms a
                                           new digit replacing what was a leading 
                                           zero in the numbers being added.
```

--------------------------------

### Atari Adventure Hero State Machine Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-07

This example defines the states, inputs, and transition table for the hero character in the Atari game 'Adventure'. It illustrates how a state machine can model character behavior and control game logic. The {*} symbols indicate transitions that should not occur in a real game implementation.

```text
List of States: 
    OFF:        This is the starting state at the game select screen.
    ACTIVE:     The hero is free to move.
    DEAD:       The hero is in the stomach of an dragon.
    WINNER:     The player has won the game. No more motion allowed.

List of Inputs:
    SELECT:  The player pressed the select switch.
    RESET:   The player pressed the reset switch.  
    CHOMP:   A dragon has swallowed the player.
    VICTORY: The chalice is in the gold castle.

State Transition Table

Current   | Input:
   State: | SELECT   | RESET    | CHOMP     | VICTORY
----------+----------+----------+-----------+----------
OFF       | OFF      | ACTIVE   | OFF {*}   | OFF {*}
----------+----------+----------+-----------+----------
ACTIVE    | OFF      | ACTIVE   | DEAD      | WINNER
----------+----------+----------+-----------+----------
DEAD      | OFF      | ACTIVE   | DEAD      | WINNER{*}
----------+----------+----------+-----------+----------
WINNER    | OFF      | ACTIVE   | WINNER{*} | WINNER{*}
----------+----------+----------+-----------+----------

```

--------------------------------

### Decimal Subtraction Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-05

Demonstrates a standard decimal subtraction problem to provide context before illustrating the binary equivalent. Shows borrowing steps and the final result.

```ascii
     124
   - 115
     ---
     |||
     ||+-->  3 - 5 = 9 with borrow of 10 ------+
     ||                               |         |
     ||              +---- borrow ----+         |
     ||              v                          |
     |+--->  2 - 1 - 1 = 0 --------------------+| 
     |                   |                     ||
     |               +---+ no borrow           ||
     |               |                         ||
     +---->  1 - 1 - 0 = 0 -------------------+||
                         |                    |||
                         +- no borrow         vvv
                                              009 = 9 final answer.
```

--------------------------------

### Bitwise AND, OR, XOR Calculation Examples

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-06

Provides the results of applying bitwise AND, OR, and XOR operations to specific byte and bitmask pairs. These examples are crucial for understanding how each operation affects binary values and are presented as answers to exercise questions.

```pseudocode
a.A = %11111111, B=%10101010
    %10101010, %11111111, %01010101
```

```pseudocode
b.A = %00000000, B=%01010101
     %00000000, %01010101, %01010101
```

```pseudocode
c.A = %11110000, B=%01110111
     %01110000, %11110111, %10000111
```

--------------------------------

### Cycle Counting Example: Branching Logic

Source: https://www.randomterrain.com/atari-2600-memories/-guide-to-cycle-counting

An example of cycle counting for code that includes branching. This snippet demonstrates how to meticulously count cycles for both taken and not-taken branches, along with other instructions like NOP and LDA, to determine the total execution time. This method accounts for potential variations in cycle counts based on conditional execution.

```6502asm
BEGIN   STA WSYNC       ;CYCLES...
        NOP             ; [0]   +2
        BIT $CC         ; [2]   +3
        BMI STUPID      ; [5]   +2 if not taken...
        NOP             ; [7]   +2   Pretend everything's
        NOP             ; [9]   +2   just smurfy, until...
        NOP             ; [11]  +2
	NOP             ; [13]
	NOP             ; [15]
	NOP		; [17]
        NOP             ; [19]  +2  IF BRANCHED
STUPID  LDA $F0         ; [21]  +3   [8]  (BMI takes +3 now)
        STA GRP0        ; *24*  +3   *11*
        LDA $F1         ; [27]  +3   [14]
        STA ENAM0       ; *30*  +3   *17*
        STA RESP0       ; *33*  +3   *20*
        STA WSYNC
```

--------------------------------

### Decimal Addition Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-05

Illustrates the process of decimal addition with carries, showing how sums greater than 9 result in a carry to the next column. This serves as a basis for understanding binary addition.

```text
        34
      + 67
------------
        ||
        |+-> 4+7 = 11 ------------------+
        |          |                    |
        |          | Carry the 10       |
        |          v                    |
        +--> 3+6 + 1 = 10 -------------+i
                       |               ||
                       | Carry the 10 ||
                       v               ||
             0+0 +     1 = 1 -------> 101 = Final answer.
             ^ ^
             | |
             +-+---- Note the leading zeros needed to finish the calculation.
```

--------------------------------

### Binary Addition Example 2

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-05

Provides a second example of binary addition with more instances of carries, including cases where three bits (1+1+1) are added together. This highlights how the carry mechanism works in more complex scenarios.

```text
   %1101111 (=111 decimal, are you confused yet :P )
  +%1111011 (=123 decimal)
   --------
    |||||||
    ||||||+- 1+1 = %10 (=2) ----------------------+
    ||||||          |                             |
    ||||||          | Carry the 2 (=%10)          |
    ||||||          v                             |
    |||||+-- 1+1 +  1 = %11 (=3) ----------------+|
    |||||                |                       ||
    |||||           +----+  Carry the 2 (=%10)   ||
    |||||           v                            ||
    ||||+--- 1+0 +  1 = %10 --------------------+||
    ||||                 |                      |||
    ||||            +----+  Carry the 2 (=%10)  |||
    ||||            v                           |||
    |||+---- 1+1 +  1 = %11 -------------------+|||
    |||                  |                     ||||
    |||             +----+  Carry the 2 (=%10) ||||
    |||             v                          ||||
    ||+----- 0+1 +  1 = %10 ------------------+||||
    ||                   |                    |||||
    ||              +----+  Carry the 2       |||||
    ||              v                         |||||
    |+------ 1+1 +  1 = %11 -----------------+|||||
    |                    |                   ||||||
    |               +----+  Carry the 2      ||||||
    |               v                        ||||||

```

--------------------------------

### batari Basic Labels and Line Numbers

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Labels in batari Basic can consist of letters, numbers, and underscores, and can start with any of these characters. They must not contain dots or match keywords. Using underscores at the start (e.g., `__my_label`) is a convention to avoid conflicts with keywords and variable aliases. Line numbers are optional but can be used for goto/gosub targets.

```assembly
; Example of label and line number usage in batari Basic


10 pfpixel 2 3 on

; A label definition
__start_of_game:

   drawscreen

; Another label, can be used for goto/gosub
_my_goto_target:
   inc a

; Labels and line numbers should not be indented
; Program statements must be indented

end
```

--------------------------------

### bB Function Declaration Example

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

An example of a batari Basic function named 'sgn' that determines the sign of a number passed via the temporary variable 'temp1'. It returns 1, 255, or 0 based on the input.

```bb
   function sgn
   rem this function returns the sign of a number
   rem if 0 to 127, it returns 1
   rem if -128 to 1 (or 128 to 255), it returns -1 (or 255)
   rem if 0, it returns 0
   if temp1=0 then return 0
   if temp1 <128 then return 1 else return 255

```

--------------------------------

### Atari 2600 Assembly Cycle Counting Example

Source: https://www.randomterrain.com/atari-2600-memories/-guide-to-cycle-counting

This assembly code snippet demonstrates cycle counting for various instructions on the Atari 2600. It illustrates how to track elapsed cycles and highlights when writes to TIA registers occur, which is crucial for precise sprite positioning and graphics.

```assembly
BEGIN: STA WSYNC    ;I begin counting here.
       NOP          ; 0 +2 = [2]    (Weenie instruction)
       LDA #0       ; 2 +3 = [5]    (Fast math, immediate)
       STA $FFFF    ; 5 +4 = [9]    (Storage, absolute)
       ROL $FFFE,X  ; 9 +7 = [16]   (Slow math, Absolute,X)
       ROL A        ; 16+2 = [18]   (Slow math, accumulator)
       STA RESP0    ; 18+3 = *21*   (Storage, zero page)
       DEY          ; 21+2 = [23]   (Weenie)
       BNE BEGIN    ; 23+3 = [26]   (Branch)

```

--------------------------------

### Macro Expansion Example

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Illustrates the result of calling the 'setscreencolors' macro. The 'callmacro' statement is replaced by the actual bB code that sets the screen colors with the provided parameters.

```bb
   COLUBK=$02
   COLUPF=$46
   scorecolor=$1C

```

--------------------------------

### Program Initialization Routines

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Contains essential routines for starting or restarting the program. This includes drawing the screen, clearing the playfield, muting sound, and resetting all game variables to their default zero state.

```Atari 2600 Assembly
__Start_Restart

    drawscreen

    pfclear

    AUDV0 = 0 : AUDV1 = 0

    a = 0 : b = 0 : c = 0 : d = 0 : e = 0 : f = 0 : g = 0 : h = 0 : i = 0
    j = 0 : k = 0 : l = 0 : m = 0 : n = 0 : o = 0 : p = 0 : q = 0 : r = 0
    s = 0 : t = 0 : u = 0 : v = 0 : w = 0 : x = 0 : y = 0 : z = 0
    var0 = 0 : var1 = 0 : var2 = 0 : var3 = 0 : var4 = 0
    var5 = 0 : var6 = 0 : var7 = 0 : var8 = 0
```

--------------------------------

### Bitwise OR Operator Example in batari Basic

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Shows an example of the bitwise OR operator (|) in batari Basic, used to turn on specific bits in a variable. If a bit in the mask is 1, the corresponding bit in the result will be 1.

```batari Basic
   a = a | 1
```

```batari Basic
   a = a | %00001111
```

--------------------------------

### Binary to Decimal Conversion Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-04

Illustrates how to convert a binary number (%00101100) to its decimal equivalent by summing the products of each binary digit and its corresponding power of 2. This showcases the place-value system in binary.

```text
   %00101100

    ||||||||

    |||||||+--- 0 * 2^0 = 0 * 1   =   0

    ||||||+---- 0 * 2^1 = 0 * 2   =   0

    |||||+----- 1 * 2^2 = 1 * 4   =   4

    ||||+------ 1 * 2^3 = 1 * 8   =   8

    |||+------- 0 * 2^4 = 0 * 16 =   0

    ||+-------- 1 * 2^5 = 1 * 32  =  32

    |+--------- 0           

    +---------- 0


      0 + 0 + 4 + 8 + 0 + 32 + 0 + 0 = 44 decimal.

```

--------------------------------

### Atari 2600 Music/Sound Data Structure Example

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-vbb

This snippet illustrates the basic data structure for a single channel of Atari 2600 sound data, consisting of Volume, Control, and Frequency values, followed by Duration.

```plaintext
V,C,F (Channel 0)
V,C,F (Channel 1)
D
V - Volume (0 to 15)
C - Control [a.k.a. tone, voice, and distortion] (0 to 15)
F - Frequency (0 to 31)
D - Duration
```

--------------------------------

### Call Game Initialization Subroutine

Source: https://www.randomterrain.com/atari-2600-memories/-how-to-draw-a-playfield

Jumps to the `GameInit` subroutine. This routine is expected to handle the initialization of game-specific variables, hardware settings, and other setup tasks required before the main game loop begins.

```assembly
JSR  GameInit
```

--------------------------------

### Include Fixed Point Math Module (Atari BASIC)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

An example of using the 'include' command to add a specific module for fixed-point math operations. This is useful for programs requiring precise mathematical calculations without relying on floating-point support.

```assembly
   include fixed_point_math.asm
```

--------------------------------

### Binary Subtraction Example 2 (Negative Result)

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-05

Demonstrates binary subtraction where the result is negative, requiring the use of 2's complement. This example follows the same subtraction procedure as before, expecting a negative outcome.

```ascii
     %1110011 (= 115 decimal)
   - %1111100 (= 124 decimal)
     --------
      |||||||
      |||||||
      ||||||+---> 1 - 0     = 1 --------------------------+
```

--------------------------------

### Playfield Resolution Example (bB)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This bB (basic) code demonstrates how to adjust playfield resolution using the DFxFRACINC registers within the DPC+ kernel. The joystick input allows dynamic control over the effect's direction.

```bB
REM bB code example for DPC+ Playfield Resolution

JOY = JOY0

LOOP:
  IF JOY = UP THEN GOSUB SET_RES_UP
  IF JOY = DOWN THEN GOSUB SET_RES_DOWN
  GOSUB DRAW_SCREEN
  GOTO LOOP

SET_RES_UP:
  ; Code to adjust DFxFRACINC values for upward effect
  RETURN

SET_RES_DOWN:
  ; Code to adjust DFxFRACINC values for downward effect
  RETURN

DRAW_SCREEN:
  ; Standard drawscreen call
  RETURN
```

--------------------------------

### Atari 2600 Scanline Data Loading Example (Assembly)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This assembly code snippet demonstrates how to load fractional increment data for background and playfield colors for Atari 2600 scanline configurations. It assumes the data is pre-defined in memory addresses.

```assembly
asm
   lda DF6FRACDATA
   lda DF4FRACDATA
   lda DF0FRACDATA
   lda DF1FRACDATA
   lda DF2FRACDATA
   lda DF3FRACDATA
end
```

```assembly
asm
   lda DF6FRACDATA
   lda DF4FRACDATA
end
```

--------------------------------

### Limiting Event Probabilities

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This code provides examples of how to limit the chance of an event occurring by comparing a random number generated by `rand` against a threshold. Different thresholds are shown for various percentage chances.

```assembly
5%   temp5 = rand : if temp5 < 13 then

10%   temp5 = rand : if temp5 < 26 then

15%   temp5 = rand : if temp5 < 38 then

20%   temp5 = rand : if temp5 < 51 then

25%   temp5 = rand : if temp5 < 64 then

30%   temp5 = rand : if temp5 < 77 then

35%   temp5 = rand : if temp5 < 90 then

40%   temp5 = rand : if temp5 < 102 then

45%   temp5 = rand : if temp5 < 115 then

50%   temp5 = rand : if temp5 < 128 then

55%   temp5 = rand : if temp5 < 141 then

60%   temp5 = rand : if temp5 < 154 then

65%   temp5 = rand : if temp5 < 166 then

70%   temp5 = rand : if temp5 < 179 then

75%   temp5 = rand : if temp5 < 192 then

80%   temp5 = rand : if temp5 < 205 then

85%   temp5 = rand : if temp5 < 218 then
```

--------------------------------

### Basic Syntax and Control Flow in batari BASIC

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Demonstrates fundamental programming constructs in batari BASIC, including variable declaration, conditional statements, loops, and jumps. These examples are crucial for understanding the basic structure of Atari 2600 programs.

```batari BASIC
rem This is a comment
end

let score = 0
const max_score = 100
dim player_x

if score > 50 then goto game_over

for i = 1 to 10
  print i
next i

game_over:
print "Game Over"

```

--------------------------------

### Configure Kernel Options with Player Colors for Paddles

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Configures kernel options including 'player1colors', 'no_blank_lines', and 'readpaddle'. This setup may lead to the loss of missile1 and missile0.

```batari Basic
set kernel_options player1colors no_blank_lines readpaddle
```

--------------------------------

### Binary to Decimal Conversion Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-04

Demonstrates how to convert a binary number (%1111011) to its decimal equivalent by multiplying each binary digit with its corresponding power of 2 and summing the results. This highlights the positional value system in binary.

```text
1111011 binary

+- 1 * 2^0 = 1 * 1  =   1
+- 1 * 2^1 = 1 * 2  =   2
+- 0 * 2^2 = 0 * 4  =   0
+- 1 * 2^3 = 1 * 8  =   8
+- 1 * 2^4 = 1 * 16 =  16
+- 1 * 2^5 = 1 * 32 =  32
+- 1 * 2^6 = 1 * 64 =  64
                               ---
                               123 decimal
```

--------------------------------

### Variable Assignment - batari Basic

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Example of assigning a value to a variable using the 'let' statement in batari Basic. The 'let' keyword is optional and ignored by the compiler.

```batari Basic
let x = x + 1
```

--------------------------------

### Atari 2600 Subroutine Call and Return

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This example illustrates a basic subroutine call using JSR (Jump to Subroutine) and its corresponding return. It highlights the importance of the stack for managing return addresses. Overuse of nested calls can lead to stack overflow.

```assembly
JSR myFunction ; Call subroutine myFunction
; ... code after subroutine returns ...

myFunction:
  ; Subroutine code goes here
  RTS ; Return from subroutine
```

--------------------------------

### batari Basic: Addition Operations

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Shows examples of addition operations in batari Basic, including variables, registers, and literal values. It highlights how results wrap around at 256 and mentions an exception for the score variable which supports a larger range.

```batari Basic
a = a + 1
COLUPF = r + $5F
player0y = player1y + 6 + temp1
```

--------------------------------

### Configuring the 16-bit Random Number Generator

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This snippet demonstrates how to set up the optional 16-bit random number generator by assigning a variable to `rand16`. This improves the quality of random numbers for games. Note that this setup is not used with the DPC+ kernel.

```assembly
dim rand16 = <var>
```

--------------------------------

### Bitwise NAND, NOR, XNOR Calculation Examples

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-06

Presents the computed results for NAND, NOR, and XNOR operations on given byte and bitmask pairs. These calculations are part of the exercises designed to test comprehension of more complex bitwise logic gates.

```pseudocode
a.A = %10110110, B=%00000000
    %11111111, %01001001, %01001001
```

```pseudocode
b.A = %11111111, B=%11111111
```

--------------------------------

### Set Player0 Position (Assembly)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Initializes the starting X and Y coordinates for the player0 sprite. These values determine the sprite's initial placement on the screen. This is common in Atari 2600/7800 game setup.

```assembly
player0x = 40 : player0y = 40
```

--------------------------------

### Decimal to Binary Conversion Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-04

Illustrates the manual process of converting a decimal number (123) to its binary equivalent by repeated division by 2 and tracking remainders. This method helps understand the underlying logic of binary representation.

```text
123 / 2 = 61 with a remainder of 1
61 / 2 = 30 with a remainder of 1
30 / 2 = 15 with a remainder of 0
15 / 2 = 7 with a remainder of 1
7 / 2 = 3 with a remainder of 1
3 / 2 = 1 with a remainder of 1
1 / 2 = 0 with a remainder of 1

123 Decimal = 1111011 binary
```

--------------------------------

### Setting Atari 2600 Playfield Register PF0 with Binary Value

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-andrew-davie-14

This example demonstrates how to load a specific binary value into the PF0 register. This is useful for understanding the bit-to-pixel mapping and for experimentation as suggested in the optional exercises. It uses standard 6502 assembly instructions.

```assembly
lda #%01000000
sta PF0
```

--------------------------------

### Atari 2600 Assembly Code Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-andrew-davie-16

This snippet demonstrates basic assembly language structure for the Atari 2600, including memory organization and drawing system setup. It is written in 6502 assembly language, commonly used for Atari 2600 development.

```assembly
;----------------------------------------------------------------------------



                org Overlay



   ; DRAWING SYSTEM

   ; place variables here



   ; etc
```

--------------------------------

### Assembly Symbol Definition and ORG Usage

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-andrew-davie-10

Shows how a symbol can be defined and then used with the ORG directive. 'START = $F800' assigns the hexadecimal value $F800 to the symbol START. Subsequently, 'ORG START' tells the assembler to set the origin of the following code to this address. Any labels defined after this ORG, like 'HelloWorld', will be assigned the value of START, demonstrating symbolic dependency.

```assembly
START = $F800; start of code - change this if you want


  ORG START

HelloWorld
```

--------------------------------

### Incorrect 'dim' Usage for Bit Aliasing (Bad Examples)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

These examples illustrate incorrect ways to use the 'dim' keyword when aliasing individual bits. Attempting to 'dim' a specific bit directly or combine 'dim' with bit indexing in certain ways can lead to errors and unexpected behavior, as shown in these 'bad examples'.

```BASIC
   dim _my_variable = a{1}
   dim _my_variable{1} = a
   dim _my_variable{1} = a{1}

```

--------------------------------

### Bank Switching with DPC+ Kernel in batari Basic

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This example illustrates proper bank switching when using the DPC+ kernel in batari Basic. Due to limited space in bank 1, it's recommended to immediately jump to bank 2 for primary code execution. The `goto __Bank_2 bank2` directive transfers control, and `bank 2` followed by `__Bank_2` establishes the new code segment. This pattern ensures efficient use of memory.

```batari Basic
   goto __Bank_2 bank2

   bank 2

   temp1=temp1

__Bank_2

```

--------------------------------

### Superchip RAM Variable Assignment Examples (Assembly)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Demonstrates variable assignments and conditional logic using Superchip RAM's special read (rXXX) and write (wXXX) variables. Write operations must be on the left, and reads on the right of assignments.

```assembly
w010=r010+1
w000=r001+r002+4
if r001<4 then 20 
w004=myfunction(r001,r002)
COLUP0=r001
pfpixel r001 r002 on
```

--------------------------------

### Jumping to Labels in Other Banks

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This snippet illustrates how to use `gosub` and `goto` to call routines or jump to labels located in different memory banks. The syntax requires specifying the bank number immediately after the label, without a space, to ensure correct execution within the bankswitched environment.

```bb
gosub __Limburger bank3
goto __Frog bank2
```

--------------------------------

### Set up Playfield - Atari 2600 Assembly

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Defines the playfield layout for the Atari 2600. This section shows a visual representation of the playfield using characters and comments, indicating where specific elements might be placed.

```assembly
;***************************************************************
;            
;  Sets up the playfield.
;            
playfield:
................................
................................
....XXXXXXXXXX....XXXXXXXXXX....
....X......................X....
....X......................X....
....X......................X....
................................
................................
....XXXX....XXX..XXX....XXXX....
................................
................................
end

```

--------------------------------

### Add Life to pfscore Bars (Starting at Bit 0)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Logic to increase the value displayed on a pfscore bar, adding a life. Multiplication by 4 and a bitwise OR with 1 is used for adding a life when starting at bit 0.

```assembly
   pfscore1 = pfscore1*4|1 ; If using a lives bar on left side.
   pfscore2 = pfscore2*4|1 ; If using a lives bar on right side.
```

--------------------------------

### Binary Addition Example 1

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-robert-m-05

Demonstrates binary addition for two numbers (34 and 67 in decimal, represented in binary). It details each step, including the binary sums (0 or 1) and the carries (%10 or 2 decimal) when the sum is 2 or more.

```text
   %0100010 (=34)
  +%1000011 (=67)
   --------
    |||||||
    ||||||+- 0+1 = %01----------------------------+
    ||||||          |                             |
    ||||||          | No carry                    |
    ||||||          v                             |
    |||||+-- 1+1 +  0 = %10 (=2) ----------------+|
    |||||                |                       ||
    |||||           +----+  Carry the 2 (=%10)   ||
    |||||           v                            ||
    ||||+--- 0+0 +  1 = %01 --------------------+||
    ||||                 |                      |||
    ||||            +----+  No Carry            |||
    ||||            v                           |||
    |||+---- 0+0 +  0 = %00 -------------------+|||
    |||                  |                     ||||
    |||             +----+  No Carry           ||||
    |||             v                          ||||
    ||+----- 0+0 +  0 = %00 ------------------+||||
    ||                   |                    |||||
    ||              +----+  No Carry          |||||
    ||              v                         |||||
    |+------ 1+0 +  0 = %01 -----------------+|||||
    |                    |                   ||||||
    |               +----+  No Carry         ||||||
    |               v                        ||||||
    +------- 0+1 +  = = %01 ----------------+||||||
                         |                  ||||||
                         |                  vvvvvvv
                         +- No Carry       %1100101 = 101 decimal = Final answer
```

--------------------------------

### Add Life to pfscore Bars (Starting at Bit 1)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Logic to increase the value displayed on a pfscore bar, adding a life. Multiplication by 4 and a bitwise OR with 2 is used for adding a life when starting at bit 1.

```assembly
   pfscore1 = pfscore1*4|2 ; If using a lives bar on left side.
   pfscore2 = pfscore2*4|2 ; If using a lives bar on right side.
```

--------------------------------

### Unresolved Symbol Error Example: Function Call in Atari BASIC

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This example demonstrates how an unresolved symbol error can occur in Atari BASIC when calling a non-existent function. If the function 'myfunction' is not defined, the assembler will raise an error.

```basic
   a = myfunction(33)

```

--------------------------------

### Handling Many Labels with 'on...gosub'

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Addresses the limitation of 'on...gosub' with a large number of labels on a single line. It demonstrates how to break down a long list of subroutine calls into multiple 'on...gosub' statements, often combined with conditional checks.

```batari Basic
if _Walk_Up < 4 then on _Walk_Up gosub __P0U0 __P0U1 __P0U2 __P0U3
_My_Temp = _Walk_Up - 4
if _My_Temp < 4 then on _My_Temp gosub __P0U4 __P0U5 __P0U6 __P0U7
_My_Temp = _Walk_Up - 8
if y < 4 then on _My_Temp gosub __P0U8 __P0U9 __P0U10 __P0U11
```

--------------------------------

### bB Function Declaration Example with Multiple Arguments

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

An example of a batari Basic function named 'max' that finds the largest of three values passed as arguments. It uses temporary variables 'temp1', 'temp2', and 'temp3' for comparisons.

```bb
  function max
  if temp1>temp2 then temp1bigger else temp2bigger 
temp1bigger if temp1>temp3 then return temp1 else return temp3 
temp2bigger if temp2>temp3 then return temp2 else return temp3

```

--------------------------------

### Define Multiple Player Color Macros (Atari BASIC)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Shows how to define macros for setting player colors and sprite positions, then using these macros with custom keywords ('pcolors', 'p0xy', 'p1xy'). This example also includes sprite data and a basic game loop.

```assembly
   macro setplayercolors
   COLUP0={1}
   COLUP1={2}
end

   def pcolors=callmacro setplayercolors

   macro setplayer0xy
   player0x={1}
   player0y={2}
end

   def p0xy=callmacro setplayer0xy

   macro setplayer1xy
   player1x={1}
   player1y={2}
end

   def p1xy=callmacro setplayer1xy

   player0:
   %00010000
   %00101000
   %01000100
   %10000010
   %01000100
   %00101000
   %00010000
end

   p0xy 20 40

   player1:
   %11111111
   %10000001
   %10000001
   %10000001
   %10000001
   %10000001
   %11111111
end

   p1xy 50 30

loop

   pcolors $0E $C6
   drawscreen
   goto loop
```

--------------------------------

### Bitwise AND Operator Examples in batari Basic

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Provides examples of using the bitwise AND operator (&) in batari Basic to manipulate individual bits within a variable. This operator is useful for masking bits, ensuring certain bits are turned off.

```batari Basic
   a = a & $0F
```

```batari Basic
   a = a & %00001111
```

--------------------------------

### Atari 2600 TIA Write-Only Registers Example

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This example demonstrates writing to a write-only register in the TIA chip to set the playfield color. Direct manipulation of these registers is crucial for graphics and sound. Note that write-only registers cannot be read back.

```assembly
LDA #$0A ; Load color value (e.g., blue)
STA COLUPF ; Store value to playfield color register
```

--------------------------------

### Example of Duplicate Labels in Atari BASIC

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This example illustrates how duplicate labels can cause assembler errors in Atari BASIC. When the same label is used for multiple lines of code, the assembler may flag it as an error. The solution is to rename one of the labels.

```basic
__Lizard_Meat a = 4

__Frozen_Gravy r = 4

__Lizard_Meat e = 10

```

--------------------------------

### Set Standard Kernel with Options

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This command configures the standard kernel with various options to customize gameplay and visuals. Options like player colors, playfield colors, and background can be enabled. The order of options does not matter, but some combinations are not allowed or have specific costs.

```assembly
set kernel_options player1colors pfcolors
```

```assembly
set kernel_options no_blank_lines readpaddle
```

```assembly
set kernel_options pfcolors pfheights background
```

--------------------------------

### batari Basic: Spacing and Statement Separation (bB)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

Illustrates acceptable and unacceptable spacing around commands and tokens in batari Basic. Proper spacing is crucial for keywords and commands to be parsed correctly, while other elements can be more flexible as long as a recognizable separator is present.

```bB
for l=1 to 10:t=t+4:next

for l = 1 to 10 : t = t + 4 : next
for   l   =1   to 10:t=t  +4: next
for l=1  to 10 : t= t+4 :next
```

--------------------------------

### Conditional Score Check Example (Less Than 10)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This example demonstrates how to check if the score is less than 10 using the extracted digits. It compares `_sc1`, `_sc2`, and `_sc3` against the hexadecimal value `$00` and `$10` respectively. Note that when checking BCD values, a '$' prefix is required.

```assembly
if _sc1 = $00 && _sc2 = $00 && _sc3 < $10 then ...

```

--------------------------------

### Atari 2600 TIA Read-Only Register Example (Collisions)

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

This example shows how to read a TIA's read-only register to detect collisions between game objects. For instance, CXM0P checks for collisions between missile 0 and player sprites. These registers provide feedback on game interactions.

```assembly
LDA CXM0P ; Load collision status for Missile 0 vs Player 0/1
CMP #$00 ; Compare with zero (no collision)
BEQ no_collision ; Branch if no collision detected
; Handle collision event here
no_collision:
  ; Continue game logic
```

--------------------------------

### Score Manipulation Examples

Source: https://www.randomterrain.com/atari-2600-memories/-batari-basic-commands

These examples demonstrate valid operations for changing the game's score. The score can be set to a specific value, incremented, decremented, or updated by adding the value of another variable. A crucial note is that when adding a variable's value, it must be BCD compliant to avoid score corruption.

```assembly
score = 1000
score = score + 2000
score = score - 10
score = score + a

```

--------------------------------

### Assemble Atari 2600 Code with DASM

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-andrew-davie-09

This command line illustrates how to use the DASM assembler to process an Atari 2600 assembly file. It specifies input and output files, a listing file, and verbosity level, enabling the creation of a runnable ROM image.

```shell
dasm kernel.asm -lkernel.txt -f3 -v5 -okernel.bin

```

--------------------------------

### 6502 Absolute Indexed Addressing Example

Source: https://www.randomterrain.com/atari-2600-memories/-tutorial-andrew-davie-19

Provides a conceptual example of using absolute indexed addressing, suitable for accessing data tables in ROM. The code snippet shows initializing the X register to 0 to act as a line number index, implying subsequent uses to access playfield values from tables.

```assembly
ldx #0   ; line #

Display
```

--------------------------------

### Assembly Language Game Creation Steps for Atari 2600

Source: https://www.randomterrain.com/atari-2600-memories/.html

This is a step-by-step guide to creating a simple game for the Atari 2600 using assembly language. It breaks down the complex process into manageable steps, suitable for beginners. Each step builds upon the previous one, leading to a functional game.

```Assembly
; Step 00: Project Setup

INCLUDE "atari.inc"

START:
    ; Game initialization code here
```

--------------------------------

### Guide to Cycle Counting in Atari 2600 6502 and TIA Programming

Source: https://www.randomterrain.com/atari-2600-memories/.html

This guide explains cycle counting for the 6502 processor and the TIA (Television Interface Adaptor) chip used in the Atari 2600. Accurate cycle counting is crucial for timing-sensitive operations in Atari 2600 programming, especially for graphics and sound. It provides methods for dealing with timing issues.

```Assembly
; Example of cycle counting

LDX #$05 ; 1 cycle
LOOP:
    DEX     ; 2 cycles
    BNE LOOP ; 2 or 3 cycles
```
Tokens:
Raw