Support Functions

func Attack(int16 ParamIdx, int16 X, int16 Y)

func CheckBitmap(uint8 Value, uint8[32] Bitmap) -> bool

func CheckTimeElapsed(uint16* LastTime, uint16 Duration) -> uint8

func Convey(int16 X, int16 Y, int16 Direction) {
    // Iterate over SW, S, SE, E, NE, N, NW, W; reverse it for counterclockwise.
    var Offsets = [(-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0)]
    if Direction != 1 {
        Offsets = reversed(Offsets)
    }

    // Get all the tiles around this conveyor.  Keep track of whether the last tile is
    // "movable": empty or pushable.
    var PrevTileMovable = true
    var Tiles = Tile[8]
    for (i, (XOffset, YOffset)) in enumerate(Offsets) {
        Tiles[i] = BoardTiles[X + XOffset][Y + YOffset]
        if Tiles[i].Type == TTEmpty {
            PrevTileMovable = true
        } else if TileTypes[Tiles[i]].Pushable == 0 {
            PrevTileMovable = false
        }
    }

    // Start rotating as soon as the previous tile is movable.
    for Index in len(Offsets) {
        var Tile = Tiles[i]
        if !PrevTileMovable {
            // Couldn't rotate this time.  If this tile is movable, we can rotate next time.
            PrevTileMovable = IsTileMovable(Tile)
        } else {
            // The previous tile can be moved.  As long as the current tile can be pushed
            // out of the way, we can rotate it into this space.
            if TileTypes[Tile.Type].Pushable {
                Rotate(X, Y, Direction, Offsets, Tiles, Index)
                // If the next tile isn't pushable, clear out the (now vacated) current tile.
                // This is not necessary if the next tile is pushable, since it will be pushed
                // into this spot.
                let NextTile = Tiles[(Index + Direction) % len(Tiles)]
                if TileTypes[NextTile.Type].Pushable == 0 {
                    let (OffsetX, OffsetY) = Offsets[Index]
                    BoardTiles[X + OffsetX][Y + OffsetY].Type = TTEmpty
                    DrawTile(X + OffsetX, Y + OffsetY)
                }
            } else {
                // We can't rotate this time since the destination isn't movable, and we won't
                // be able to rotate next time since the source won't be movable.
                PrevTileMovable = false
            }
        }
    }
}


func Rotate(int16 X, int16 Y, int16 Direction, int16 Offsets, int16 Tiles, int16 Index) {
    // Calculate source (Index) and destination (Index-1) locations.
    let (SrcXOffset, SrcYOffset) = Offsets[Index]
    let (SrcX, SrcY) = (X + SrcXOffset, Y + SrcYOffset)
    let (DestXOffset, DestYOffset) = Offsets[(Index - Direction) % len(Offsets)]
    let (DestX, DestY) = (X + DestXOffset, Y + DestYOffset)
    
    // If the current tile has params, move it.
    if TileTypes[Tiles[Index].Type].Cycle > -1 {
        let SrcTile = BoardTiles[SrcX][SrcY]
        let SrcParamIdx = ParamIdxForXY(SrcX, SrcY)
        // Set the correct tile types at the source and destination, then move.
        BoardTiles[SrcX][SrcY] = Tiles[Index]
        BoardTiles[DestX][DestY].Type = TTEmpty
        MoveTileWithIdx(SrcParamIdx, DestX, DestY)
    } else {
        // No params to move, just copy the tile.
        BoardTiles[DestX][DestY] = Tiles[Index]
        DrawTile(DestX, DestY)
    }
}


//
// Check if a tile is movable for a conveyor belt.  Empty and pushable tiles are movable.
//
func IsTileMovable(Tile tile) -> Bool {
    if Tile.Type == TTEmpty {
        return true
    } else {
        return (TileTypes[Tile.Type].Pushable != 0)
    }
}

func Destroy(int16 X, int16 Y)

func DieAttackingTile(int16 ParamIdx, int16 X, int16 Y)

func Distance(int16 A, int16 B) -> int16

func DrawTile(int16 X, int16 Y)

func Explode(int16 CenterX, int16 CenterY, int16 Mode)

func MoveTileWithIdx(int16 ParamIdx, int16 X, int16 Y)

func ParamIdxForXY(int16 X, int16 Y) -> int16

func PlaySoundPriority(int16 priority, string data)

func PromptQuit()

func PromptSaveWorld(string* Prompt, string* Filename, string* Extension)

func Random(int16 Max) -> int16

func RandomStep() -> (int16 StepX, int16 StepY) {
    // Get a value between [-1,1] and assign it to StepX.
    let StepX = Random(3) - 1

    // Set StepY only if we got 0 for StepX.
    let StepY
    if StepX == 0 {
        // Get a value that's either -1 or 1 and assign it to StepY.
        StepY = 2*Random(2) - 1
    } else {
        StepY = 0
    }

    return (StepX, StepY)
}

func RedrawBorder()

func RemoveParamIdx(int16 Index)

func RunCodeCycle(int16 ParamIdx, uint8* InstructionPtr, string* DefaultTitle)

func SayMessage(int16 Duration, string* Message)

func SeekStep(int16 X, int16 Y) -> (int16 StepX, int16 StepY) {
    var StepX = 0
    var StepY = 0

    // Pick randomly whether to move on the X or Y axis
    let PickedY = (Random(2) == 1)

    // If we picked Y but are already aligned on the Y axis, set X instead
    if !PickedY || PlayerY == Y {
        // Set StepX towards the player
        StepX = StepForDelta(PlayerX - X)
    }

    // If we didn't move on the X axis, move on the Y axis
    if StepX == 0 {
        // Set StepY towards the player
        StepY = StepForDelta(PlayerY - Y)
    }

    // Reverse the result if the player is energized
    if EnergizerCycles > 0 {
        StepX = -StepX
        StepY = -StepY
    }

    return (StepX, StepY)
}

func Send(int16 Index, string Label, int16 OverrideLock) -> int16

func Shoot(uint8 ShootType, int16 X, int16 Y, int16 StepX, int16 StepY, uint8 Owner) -> uint8

func ShowDebugPrompt()

func ShowHelpFile(string* Filename, string* Title)

func Spawn(int16 X, int16 Y, int16 Type, int16 Color, int16 Cycle, ParamRecord* SourceParams)

func StepForDelta(int16 Delta) -> int16

func TryPush(int16 X, int16 Y, int16 StepX, int16 StepY)

func UpdateSideBar()