sudo dpkg -i tidepod-1.0.0-rc5-linux-amd64.deb
sudo apt-get install -f   # Resolves any missing system OpenGL/X11 libraries

tidepod new HelloCart --type 8k --menu "HELLO CART" --path ./HelloCart
cd HelloCart

 1: #include <stdio.h>
 2: #include <conio.h>
 3: 
 4: int main(void) {
 5:     // Initialize 40-column hardware text mode
 6:     ti_text_mode(40);
 7: 
 8:     // Set screen border color to Dark Blue (palette index 4)
 9:     bordercolor(4);
10: 
11:     // Clear screen and position cursor at column 4, row 3
12:     clrscr();
13:     gotoxy(4, 3);
14:     puts("HELLO FROM C ON TI-99/4A!");
15: 
16:     // Display toolchain banner
17:     gotoxy(4, 5);
18:     puts("BUILT WITH TIDEPOD C99 SUITE");
19: 
20:     // Display interactive prompt
21:     gotoxy(4, 8);
22:     puts("PRESS ANY KEY TO CONTINUE...");
23: 
24:     // Scan keyboard matrix and wait for user keypress
25:     int key = cgetc();
26: 
27:     // Output confirmation with ASCII character value
28:     gotoxy(4, 11);
29:     printf("KEY DETECTED: ASCII %d ('%c')
", key, (char)key);
30: 
31:     gotoxy(4, 13);
32:     puts("SYSTEM READY. HALTING IN IDLE LOOP.");
33: 
34:     // Bare-metal halt loop (prevents crash on OS return)
35:     while (1) {
36:     }
37: 
38:     return 0;
39: }

tidepod sync && make
tidepod run

tidepod new SpaceBlaster --type banked --size 512 --menu "SPACE BLASTER" --path ./SpaceBlaster
cd SpaceBlaster

 1: #include <stdio.h>
 2: #include <conio.h>
 3: 
 4: // Tidepod Extended BASIC C runtime library bindings
 5: extern void pattern(int char_code, const char *hex_pattern);
 6: extern void sprite(int num, int char_code, int color, int r, int c, int rv, int cv);
 7: extern void locate(int num, int r, int c);
 8: extern void color(int char_set, int f_color, int b_color);
 9: extern void joyst(int unit, int *x, int *y);
10: extern void sound(int duration_ms, int freq, int vol);
11: extern void vsync(void);
12: 
13: int main(void) {
14:     // Player spaceship coordinates (pixels)
15:     int ship_x = 128;
16:     int ship_y = 96;
17:     int joy_x = 0;
18:     int joy_y = 0;
19: 
20:     // Enemy star coordinates and automatic velocity
21:     int enemy_x = 30;
22:     int enemy_y = 40;
23:     int enemy_vx = 2;
24:     int enemy_vy = 1;
25: 
26:     // Switch to Graphics I Mode (32x24 tiles with 32 hardware sprites)
27:     ti_text_mode(32);
28:     clrscr();
29: 
30:     // Define custom 8x8 sprite pattern 65 ('A') for Player Spaceship
31:     // Hex: 18 (..XX....), 3C (.XXXX...), 7E (XXXXXX..), DB (XX.XX.XX), FF (XXXXXXXX), 24 (..X..X..), 5A (.X.XX.X.), 42 (.X....X.)
32:     pattern(65, "183C7EDBFF245A42");
33: 
34:     // Define custom 8x8 sprite pattern 66 ('B') for Enemy Hazard Star
35:     pattern(66, "002418FF18240000");
36: 
37:     // Spawn Hardware Sprite #1: Player Ship (Cyan, 7) at (96, 128)
38:     sprite(1, 65, 7, ship_y, ship_x, 0, 0);
39: 
40:     // Spawn Hardware Sprite #2: Enemy Star (Dark Red, 6) at (40, 30)
41:     sprite(2, 66, 6, enemy_y, enemy_x, 0, 0);
42: 
43:     // Play startup fanfare on PSG: 440 Hz (A4) for 200 ms at full volume (0)
44:     sound(200, 440, 0);
45: 
46:     // 60 FPS Interactive Game Loop
47:     while (1) {
48:         // 1. Wait for VDP Vertical Blank interrupt (prevents visual tearing)
49:         vsync();
50: 
51:         // 2. Poll Joystick #1 (Wired to 9901 CRU)
52:         joyst(1, &joy_x, &joy_y);
53: 
54:         // 3. Update player position based on joystick deflection
55:         if (joy_x != 0 || joy_y != 0) {
56:             ship_x += (joy_x * 2);
57:             ship_y -= (joy_y * 2); // Invert Y because screen rows increase downwards
58: 
59:             // Clamp player to visible screen boundaries
60:             if (ship_x < 8) ship_x = 8;
61:             if (ship_x > 248) ship_x = 248;
62:             if (ship_y < 8) ship_y = 8;
63:             if (ship_y > 184) ship_y = 184;
64: 
65:             // Update Sprite #1 position in VRAM Attribute Table
66:             locate(1, ship_y, ship_x);
67:         }
68: 
69:         // 4. Update and bounce enemy hazard
70:         enemy_x += enemy_vx;
71:         enemy_y += enemy_vy;
72: 
73:         // Bounce off screen walls and play a bounce blip
74:         if (enemy_x <= 8 || enemy_x >= 248) {
75:             enemy_vx = -enemy_vx;
76:             sound(30, 880, 5); // Short high-pitch chirp (880 Hz, volume 5)
77:         }
78:         if (enemy_y <= 8 || enemy_y >= 184) {
79:             enemy_vy = -enemy_vy;
80:             sound(30, 660, 5); // Short mid-pitch chirp (660 Hz, volume 5)
81:         }
82: 
83:         // Update Sprite #2 position in VRAM
84:         locate(2, enemy_y, enemy_x);
85:     }
86: 
87:     return 0;
88: }

tidepod sync && make
tidepod run

tidepod add resources/tileset.dat
tidepod add resources/level_map.dat
tidepod sync

 1: #include <stdio.h>
 2: #include <conio.h>
 3: #include "resource_defs.h"
 4: #include "resource_copy.h"
 5: 
 6: // Allocate persistent level buffer in CPU BSS (off the C stack!)
 7: static unsigned char s_active_level[1024];
 8: 
 9: int main(void) {
10:     // Initialize 32-column graphics mode
11:     ti_text_mode(32);
12:     clrscr();
13: 
14:     // 1. Stream 2048 bytes of background tileset from banked ROM into VRAM at 0x0000.
15:     //    rom_to_vram handles bank switching, VDP address register programming,
16:     //    burst byte streaming, and original bank restoration!
17:     rom_to_vram(unwrap(tileset), 0x0000);
18: 
19:     // 2. Stream 1024 bytes of level map data from banked ROM into CPU RAM buffer
20:     rom_to_ram(unwrap(level_map), s_active_level, sizeof(s_active_level));
21: 
22:     // 3. Draw first 32 tiles of the level onto the top row of the screen
23:     gotoxy(0, 0);
24:     for (int i = 0; i < 32; i++) {
25:         cputc(s_active_level[i]);
26:     }
27: 
28:     gotoxy(2, 5);
29:     puts("ASSET PIPELINE STREAMING COMPLETE!");
30:     gotoxy(2, 7);
31:     printf("TILES LOADED: %u BYTES TO VRAM
", (unsigned int)tileset_size);
32:     gotoxy(2, 8);
33:     printf("MAP LOADED:   %u BYTES TO RAM
", (unsigned int)level_map_size);
34: 
35:     // Idle loop
36:     while (1) {
37:     }
38: 
39:     return 0;
40: }

 1: #include <stdio.h>
 2: #include <string.h>
 3: #include <conio.h>
 4: 
 5: // Fast raster math function placed in ultra-fast 16-bit Scratchpad RAM (0x8300)
 6: __attribute__((section(".scratchpad")))
 7: int fast_sin(int angle) {
 8:     static const int s_sin_lut[8] = { 0, 70, 100, 70, 0, -70, -100, -70 };
 9:     return s_sin_lut[angle & 7];
10: }
11: 
12: // Audio playback routine placed in Lower 8K Persistent RAM (0x2000)
13: // Guaranteed to remain accessible regardless of which ROM bank is currently active!
14: __attribute__((section(".persistent")))
15: void persistent_audio_tick(void) {
16:     // Audio driver code safe from bank swaps
17: }
18: 
19: // SAFE: 256-byte sector buffer placed in .bss Expansion RAM (NOT on the stack!)
20: static unsigned char s_disk_sector_buffer[256];
21: 
22: int safe_process_sector(unsigned char fill_pattern) {
23:     // Fills the 256-byte static buffer safely
24:     memset(s_disk_sector_buffer, fill_pattern, sizeof(s_disk_sector_buffer));
25:     
26:     int checksum = 0;
27:     for (int i = 0; i < 256; i++) {
28:         checksum += s_disk_sector_buffer[i];
29:     }
30:     return checksum;
31: }
32: 
33: int main(void) {
34:     ti_text_mode(40);
35:     clrscr();
36: 
37:     int val = fast_sin(2);
38:     int sum = safe_process_sector(0x42);
39: 
40:     printf("SCRATCHPAD SIN(2): %d
", val);
41:     printf("STATIC BSS BUFFER CHECKSUM: %d
", sum);
42:     puts("MEMORY TEST COMPLETED WITH ZERO STACK VIOLATIONS.");
43: 
44:     while (1) {
45:     }
46: 
47:     return 0;
48: }

 1: // Code executed natively on the 100MHz 16-bit F18A GPU coprocessor
 2: void gpu_main(void) {
 3:     // Direct pointer to F18A VRAM (mapped at address 0x0000 in GPU memory space)
 4:     volatile unsigned char *vram = (volatile unsigned char *)0x0000;
 5:     
 6:     // Rapidly fill screen tiles with a dynamic XOR geometric pattern
 7:     for (int y = 0; y < 24; y++) {
 8:         for (int x = 0; x < 40; x++) {
 9:             int offset = (y * 40) + x;
10:             vram[offset] = (unsigned char)((x ^ y) + 65);
11:         }
12:     }
13:     
14:     // Halt GPU execution cleanly and wait for next host trigger
15:     __asm__ volatile ("idle");
16: }

tidepod add src/gpu_fx.c --gpu --gpu-base 0x3000 --gpu-stack 0x3F00
tidepod sync

 1: #include <stdio.h>
 2: #include <conio.h>
 3: #include "resource_defs.h"
 4: #include "resource_copy.h"
 5: #include "gpu_fx_map.h"
 6: 
 7: // F18A hardware register control routines
 8: extern void f18a_unlock(void);
 9: extern void f18a_gpu_start(unsigned int vram_addr);
10: 
11: int main(void) {
12:     ti_text_mode(40);
13:     clrscr();
14:     puts("INITIALIZING F18A HARDWARE...");
15: 
16:     // 1. Unlock enhanced F18A registers by writing magic sequence >55, >55 to VR57
17:     f18a_unlock();
18: 
19:     // 2. Stream compiled GPU machine code from cartridge ROM into VRAM at 0x3000
20:     rom_to_vram(unwrap(gpu_fx), 0x3000);
21: 
22:     gotoxy(0, 5);
23:     puts("LAUNCHING 100 MHZ F18A GPU SHADER...");
24: 
25:     // 3. Trigger GPU execution at VRAM address 0x3000 via VDP Register 54
26:     f18a_gpu_start(0x3000);
27: 
28:     gotoxy(0, 12);
29:     puts("GPU EXECUTED SUCCESSFULLY!");
30: 
31:     while (1) {
32:     }
33: 
34:     return 0;
35: }

 1: #include <stdio.h>
 2: #include <string.h>
 3: #include <conio.h>
 4: 
 5: // Static I/O buffer in BSS to prevent stack overflow!
 6: static char s_io_buffer[128];
 7: 
 8: int main(void) {
 9:     ti_text_mode(40);
10:     clrscr();
11:     puts("TI-99/4A DISK I/O DEMONSTRATION");
12: 
13:     // 1. Open file for writing on Floppy Drive 1
14:     FILE *fp = fopen("DSK1.SCORES", "w");
15:     if (!fp) {
16:         puts("ERROR: CANNOT CREATE DSK1.SCORES");
17:         while (1) {}
18:     }
19: 
20:     // 2. Write high score records to disk
21:     fprintf(fp, "DANNY:98500
");
22:     fprintf(fp, "RETRO:82100
");
23:     fclose(fp);
24:     puts("HIGH SCORES SAVED SUCCESSFULLY.");
25: 
26:     // 3. Re-open file for sequential reading
27:     fp = fopen("DSK1.SCORES", "r");
28:     if (!fp) {
29:         puts("ERROR: CANNOT READ DSK1.SCORES");
30:         while (1) {}
31:     }
32: 
33:     // 4. Stream and print records line by line
34:     int line_num = 1;
35:     while (fgets(s_io_buffer, sizeof(s_io_buffer), fp)) {
36:         gotoxy(2, 6 + line_num);
37:         printf("RECORD %d: %s", line_num, s_io_buffer);
38:         line_num++;
39:     }
40:     fclose(fp);
41: 
42:     gotoxy(2, 11);
43:     puts("DISK I/O OPERATION COMPLETED OK.");
44: 
45:     while (1) {
46:     }
47: 
48:     return 0;
49: }

tidepod new FileTool --type ea5 --path ./FileTool
cd FileTool && make

make debug
ti994a-emu --cart mygame.rpk --gdb 3333

tms9900-elf-gdb mygame.elf \
  -ex 'target remote :3333' \
  -ex 'break main' \
  -ex 'continue'

ti994a-emu --cart mygame.rpk --headless --f18a \
  --keys "WAIT:240 SPACE WAIT:60 2 WAIT:300" \
  --screenshot-at 600 --screenshot-path verification.png \
  --frames 620

# In your project root, symlink or copy the skill:
mkdir -p .cursor/skills
cp -r /path/to/tidepod/.cursor/skills/ti99-tidepod-gamedev .cursor/skills/