GitHub - jackdoe/roblox-python-tower-defense: save the core by writing python!

PythonTD

NB: 90% written by AI, nudged by jackdoe; run with rojo serve Tower defense with programmable units.

while True:
    enemies = self.scan()
    if len(enemies) > 0:
        self.set_target(nearest(enemies))
        self.fire(BULLET)

Ammo Types

Gundams use ammo from their magazine. Player weapons cost scrap (half gundam cost, half damage).

Gundam Weapons

Player Weapons

Player ROCKET applies OILED. Both ICE weapons freeze (60% slow).

Debuffs

Combos

Bots can SHOCK enemies to trigger powerful combos:

Combos stack MULTIPLICATIVELY! Order: cargo -> oiled -> burning -> slow

Example: 5 cargo + oiled + burning + 60% slow on 30 base shock:

30 × 7.6 (cargo) × 2 (oil) × 1.5 (burn) × 1.6 (slow) = 1094 damage!

• Chain lightning range: 15 units from target
• Bot stuns for 2s after shocking (vulnerable!)

Types

Objects: Self and Others

Each unit (Gundam, Bot, Player) is an OBJECT with data and actions.

Self - Your Unit

self refers to the unit running the code:

self.pos                 # read your position
self.carrying            # read how much scrap you have
self.scan()              # perform a scan action
self.fire(BULLET)        # perform a fire action

Other Units - G1, G2, B1, B2, etc.

You can read data from other units on your team:

B1.pos                   # where is Bot 1?
B1.carrying              # how much scrap does Bot 1 have?
G3.ammo                  # how much ammo does Gundam 3 have?

Properties vs Methods

Properties are data you READ (no parentheses):

self.pos                 # [x, z] position
self.carrying            # number of scrap
self.ammo                # current ammo (Gundam)
self.max_ammo            # max ammo capacity (Gundam)
self.max_capacity        # max scrap capacity (Bot/Player)
enemy.hp                 # enemy health
enemy.is_boss            # True/False

Methods are actions you DO (use parentheses):

self.scan()              # returns list of enemies
self.fire(BULLET)        # shoots, returns True/False
self.collect()           # picks up scrap
self.teleport([0, 0])    # moves to position
self.set_target(enemy)   # aims at enemy

Example - Coordinated Attack

# Bot checks if Gundam needs help
if G1.ammo < 50 and self.carrying > 0:
    self.say("G1 low on ammo!")
    self.teleport([0, 0])
    self.deposit()

Bot Abilities

Shock damage examples: 5 cargo = 228 dmg, 10 cargo = 1732 dmg!

Gundam Abilities

Player Abilities

Selectors

These pick ONE enemy from a list:

Example:

enemies = self.scan()          # get list of enemies
target = nearest(enemies)      # pick the closest one
self.set_target(target)        # aim at it

Enemy Properties

When you scan, you get Enemy objects:

Global Variables

How Python Works

Your code goes through 3 stages before running:

1. LEXER - Reads your text and breaks it into tokens. if x > 5: becomes: [IF] [x] [>] [5] [:]. Tracks indentation for Python blocks.

2. COMPILER - Converts tokens into bytecode instructions. x = 5 becomes: LOAD_CONST 5, STORE_VAR x. Checks for errors like undefined variables.

3. VIRTUAL MACHINE (VM) - Executes bytecode one instruction at a time. Uses a stack to compute values. Each CPU tick runs multiple instructions.

CPU, RAM, and Power

Each unit has CPU speed (Hz), RAM (bytes), and Power multiplier.

CPU (Speed)

• Base: 1 Hz
• Each upgrade: +2 Hz
• Cost: 200 scrap, then x2 per upgrade

Higher Hz = your program runs faster AND you fire faster!

• Fire rate scales with CPU: actualRate = baseRate / cpuHz
• At 5 Hz with BULLET (0.2s): fires every 0.04s instead of 0.2s!
• Bot movement speed also scales: baseSpeed + (cpuHz - 1) × 4

fire() is BLOCKING - your program waits for the cooldown.

RAM (Program Size)

• Base: 32 bytes
• Each upgrade: +32 bytes
• Cost: 75 scrap, then x1.5 per upgrade

RAM limits your program size (bytecode instructions).

• Simple loop = ~15 bytes
• Full AI = ~60+ bytes

Power (Damage Multiplier)

• Base: x1
• Each upgrade: +1x
• Cost: 200 scrap, then x2 per upgrade

Power multiplies all damage dealt by the unit. Also extends effective range (+20% per power level).

Economy

• Starting scrap: 1000
• Each player has their own scrap balance (not shared!)
• Scrap drops from killed enemies
• Your bots deposit scrap to YOUR balance
• Use self.drop(n) to share scrap with teammates
• Each scrap piece = 10 scrap currency
• Damage scoreboard shows who's contributing!

Costs

First Challenge

The default gundam program fires but NEVER RELOADS!

while True:
    enemies = self.scan()
    if len(enemies) > 0:
        self.set_target(nearest(enemies))
        self.fire(BULLET)

Your first task: add reload logic. But there's a catch...

Base RAM (32 bytes) is NOT enough for a full reload program!

You must choose wisely:

• Write minimal code that fits in 32 bytes
• Or upgrade RAM first (costs scrap)
• Or accept running dry and reloading manually

This is the machinist's dilemma: code efficiency vs upgrades.

Tips

• ICE enemies before ROCKET for shatter bonus (freezes at 50%+ slow)
• SHOCK oiled enemies for 2x damage + explosion
• SHOCK burning enemies for 1.5x + chain lightning
• Stack debuffs before SHOCK for multiplicative damage!
• SHOCK teleports bot to target, then consumes all cargo
• Bots can teleport([0,0]) to instantly return to core
• Lower range = more damage (40/range). Power boosts both damage and range.
• Check enemy.is_boss to prioritize threats
• Use B1.carrying to coordinate between units