Assembly do GBA: referência de instruções e sintaxe

Este artigo é uma referência para consultar enquanto você acompanha a série Do hardware ao jogo e o Tower Defense em Assembly. Ele explica o que as instruções leem, o que modificam e como a sintaxe se relaciona com a CPU e com a memória.

O alvo é o Game Boy Advance, com CPU ARM7TDMI, arquitetura ARMv4T e instruções no estado ARM, usando GNU assembler. O Game Boy clássico e o Game Boy Color usam outra CPU: os comandos daqui não são uma referência para esses consoles. Thumb também existe no GBA, mas tem formatos e restrições diferentes dos exemplos ARM desta série.

A referência cobre todas as famílias de instruções e diretivas que aparecem nos seis exemplos e no Tower Defense didático. Também apresenta algumas operações complementares. As variantes especiais e os detalhes completos de codificação ficam nos manuais indicados ao final. Salvo indicação contrária, os exemplos usam registradores comuns, sem os comportamentos especiais de instruções que escrevem em pc.

Como consultar

Cada link abaixo leva diretamente à seção correspondente. Nos outros artigos, os links de referência aparecem junto do conceito ou do código que os utiliza. Você pode abrir a referência em outra aba para conservar a posição no tutorial.

Os blocos curtos deste artigo são exemplos de leitura e de sintaxe, não ROMs completas. Endereços simbólicos como coins precisam ser definidos e organizados pelo programa que os utiliza. Para executar um programa inteiro, use os seis exemplos completos ou a primeira ROM explicada passo a passo.

Sintaxe

Uma linha pode conter um label, uma operação, seus operandos e um comentário. Aqui está uma linha real que pode aparecer dentro de uma rotina:

paint: strh r1, [r0], #2    @ Escrever um pixel e avancar dois bytes.

#20 significa o valor imediato 20. =coins, em ldr r0, =coins, pede ao assembler que carregue o valor do símbolo; não significa ler a variável. {r4, lr} é uma lista de registradores, usada em operações como push. O ponto em .equ ou .section indica uma diretiva das ferramentas, não uma instrução da CPU.

Não existe uma regra única de quantidade de operandos. add normalmente tem destino e duas entradas; cmp tem duas entradas e não guarda um resultado numérico; b recebe um destino de execução. Não interprete toda primeira posição como um destino.

Nos nomes ARM, sufixos acrescentam informações: em strh, h é meia palavra; em subne, ne é uma condição; em subs, s solicita atualização das flags. São coisas diferentes. Para os comandos usados aqui, o GNU assembler aceita, por exemplo, addeq e addseq: a segunda forma soma sob condição EQ e atualiza as flags.

Registradores

Os registradores da CPU guardam valores de 32 bits. Os nomes não determinam se o valor é uma posição, um endereço ou uma cor: o programa dá esse significado aos bits.

Ler uma palavra da RAM exige colocar um endereço em um registrador e usar uma instrução de carga. Uma soma comum trabalha nos registradores; não existe neste conjunto uma forma add [endereco], #1 para incrementar diretamente uma variável de memória.

No estado ARM, a leitura usual de pc por uma instrução considera o pipeline e corresponde ao endereço da instrução atual mais oito bytes. Por isso uma desmontagem pode mostrar uma carga relativa a pc. Isso não quer dizer que o programa pulou duas instruções. Para saltos e retornos, use os padrões descritos em B e labels e BL e BX.

Não confunda estes registradores com KEYINPUT, VCOUNT ou DISPCNT: esses são registradores do hardware periférico, acessados por endereços de I/O. r0 pode conter o endereço de DISPCNT, mas não se torna o próprio DISPCNT.

Números e imediatos

20 e 0x14 representam o mesmo número. 0x anuncia hexadecimal; os dígitos vão de 0 a 9 e A a F. Um byte tem oito bits, uma meia palavra tem 16 e uma palavra ARM tem 32.

Uma palavra com os bits 0xFFFFFFFF representa 4.294.967.295 quando interpretada sem sinal e -1 em complemento de dois com sinal. Os registradores não carregam uma etiqueta de tipo: a operação e a condição escolhidas determinam a interpretação.

As contas comuns produzem um resultado de 32 bits. Somar um a 0xFFFFFFFF deixa zero nos 32 bits do destino; as flags, quando solicitadas, ajudam a identificar carry e overflow. O V de overflow com sinal não é a mesma coisa que o C de carry sem sinal.

Nem toda constante de 32 bits cabe no campo imediato de uma instrução ARM. Em muitas operações de processamento de dados, o imediato é formado por oito bits com uma rotação em passos pares. Portanto, “é um número pequeno no texto” ou “cabe em um registrador” não basta para garantir a codificação.

mov r0, #20
ldr r1, =0x12345678

No segundo caso, a pseudoinstrução deixa o assembler escolher uma sequência adequada para a constante. Ele pode usar uma instrução equivalente de movimento ou uma leitura de um literal próximo ao código. Esse mecanismo é explicado em LDR e STR e .ltorg.

MOV

mov destino, origem coloca no destino uma cópia do valor da origem. A origem pode ser outro registrador ou um imediato que a ferramenta consiga codificar.

mov r0, #20
mov r1, r0
mov r2, r1, lsl #1

Ao final, r0 e r1 contêm 20; r2 contém 40. O deslocamento participa da operação que produz o valor de r2; não altera r1.

O mov comum não lê nem escreve uma variável na RAM e não modifica as flags. movs atualiza as flags aplicáveis à operação lógica. moveq e movne executam o movimento apenas quando a condição está satisfeita. Essas condições usam flags anteriores, não fazem uma comparação implícita com a origem do movimento.

O GNU assembler pode transformar algumas constantes em uma forma equivalente, como mvn. Para saber o que foi realmente emitido, consulte a desmontagem do ELF.

LDR e STR

ldr destino, [endereco] carrega uma palavra da memória. str origem, [endereco] armazena uma palavra. A direção é importante: em str, o primeiro operando é a origem do valor, e a memória é o destino.

ldr r0, =coins
ldr r1, [r0]
add r1, r1, #5
str r1, [r0]

A primeira linha coloca em r0 o endereço representado por coins. A segunda lê o saldo. A terceira calcula o novo saldo. Só a quarta altera a variável na RAM. Se o saldo era 20, passa a ser 25.

ldr r0, =coins é uma pseudoinstrução, reconhecida pelo assembler. O sinal = distingue esse pedido da leitura com colchetes. Se o símbolo representa um endereço, carregamos um endereço; se representa uma constante definida com .equ, carregamos essa constante.

Se r1 contém 0x12345678, strh r1, [r0] escreve somente 0x5678. Não há uma instrução strsh: escrever uma largura menor descarta os bits superiores, independentemente da interpretação com sinal.

Na RAM, nossos acessos de palavra ficam alinhados em quatro bytes; os de meia palavra, em dois. Não suponha que acessos desalinhados se comportem como uma leitura comum. No GBA, a região também importa: a VRAM tem restrições próprias, e uma escrita de byte não se comporta como um armazenamento isolado de byte em RAM. Os exemplos desenham com strh.

O GBA usa little-endian: 0x12345678 ocupa, em endereços crescentes, os bytes 78 56 34 12. Isso descreve a organização dos bytes, não uma inversão do valor aritmético. As formas de carga e armazenamento usadas nesta série não atualizam NZCV.

Endereçamento

Um endereço mede bytes. Incrementar um ponteiro em um não significa automaticamente avançar uma palavra ou um pixel.

Considere cada linha da tabela de forma independente, começando com r0 = 0x02000000:

O ! solicita atualização da base na forma pré-indexada. Na forma pós-indexada, depois dos colchetes, a atualização acontece após o acesso. Isso modifica o registrador da base, não uma variável que por acaso existisse no endereço antigo.

Para palavras, certas formas também permitem um índice em registrador com deslocamento:

ldr r2, [r0, r1, lsl #2]
strh r4, [r5], #2

Na primeira linha, o índice é multiplicado por quatro para selecionar uma palavra. Na segunda, escrevemos um pixel e avançamos dois bytes. As formas de endereçamento não são idênticas para todas as larguras: no ARM7TDMI, não copie o índice escalado de ldr diretamente para uma forma de ldrh ou strh.

Você usa esses padrões no desenho de retângulos: o ponteiro percorre pixels consecutivos e depois salta o espaço que falta até a próxima linha.

ADD, SUB e RSB

rsb inverte a ordem da subtração. É útil para calcular 240 - largura ou negar um valor com 0 - valor.

mov r1, #12
add r0, r1, #4
sub r2, r1, #4
rsb r3, r1, #0

Os resultados são 16 em r0, 8 em r2 e -12, na representação de 32 bits, em r3. r1 permanece 12.

Sem s, essas operações não atualizam as flags. adds, subs e rsbs atualizam NZCV. Um laço pode usar subs contador, contador, #1 seguido de bne para repetir enquanto o resultado não for zero. O sufixo condicional em subne tem outra função: escolher se a subtração será executada.

No Tower Defense, rsblt r2, r2, #0 nega uma diferença apenas se ela for negativa, de acordo com a comparação anterior. Para os pequenos valores de posição usados ali, isso permite calcular o valor absoluto. O menor inteiro com sinal de 32 bits é um caso especial: seu positivo não cabe nessa mesma representação.

MUL

mul destino, entrada1, entrada2 multiplica dois registradores e guarda os 32 bits inferiores do produto. Não recebe um imediato na posição dos multiplicandos.

mov r1, #80
mov r5, #240
mul r6, r1, r5

r6 passa a conter 19.200. Esse é o início do cálculo da posição de uma linha na imagem.

O ARM7TDMI tem restrições de operandos que não devem ser substituídas pelas regras de um ARM mais recente. No formato ARM usado aqui, mantenha o destino diferente do primeiro multiplicando: mul r6, r1, r5 atende a essa restrição. Os exemplos usam mul sem atualizar flags.

Para um produto completo de 64 bits, existem outras instruções, como umull e smull, resumidas na tabela de operações complementares. Um produto de 32 bits que transborda não gera automaticamente uma exceção do jogo.

AND, ORR, EOR, BIC e MVN

Essas operações trabalham em cada posição dos bits. Elas não interpretam o valor como “botão”, “estado” ou “cor”.

Considere apenas os quatro bits inferiores para visualizar a diferença:

valor = 1100     mascara = 1010
AND   = 1000
OR    = 1110
XOR   = 0110
BIC   = 0100

No exemplo dos botões, mvn troca a convenção ativa em zero por bits um para botões pressionados. Um and com 0x03FF elimina os bits que não pertencem aos dez controles. Depois, bic remove os botões que já estavam pressionados no quadro anterior.

Na forma comum, essas instruções não atualizam flags. As formas com s, como orrs, atualizam N e Z, podem atualizar C conforme o deslocamento do operando e preservam V. Por exemplo, orrs r0, r0, r1 permite testar se dois valores eram ambos zero: o resultado só será zero nesse caso. Esse padrão aparece na verificação de fim da onda do Tower Defense.

Deslocamentos

Um deslocamento pode compor o segundo operando de uma instrução. O ARM tem um circuito de deslocamento associado a essas operações; não é necessário modificar o registrador de origem antes de usá-lo.

mov r0, #3
mov r1, r0, lsl #4
add r2, r1, r0, lsl #1

r1 recebe 48. r2 recebe 48 + 6, ou 54. r0 continua 3. Nos números usados para coordenadas, lsl #4 equivale a multiplicar por 16, desde que o resultado não ultrapasse a largura disponível.

Para valores sem sinal, lsr pode representar uma divisão por potência de dois descartando o resto. Para negativos, asr preserva o sinal e não equivale em todos os casos à divisão de uma linguagem que arredonda em direção a zero. Existe também rrx, uma rotação de um bit que envolve a flag C.

As quantidades zero e 32 têm particularidades de codificação e efeito. Os exemplos introdutórios usam deslocamentos positivos pequenos; para outras quantidades, confira a instrução e o formato no manual.

Flags e sufixo S

As flags principais ficam no CPSR:

N não significa, sozinho, que uma comparação com sinal deu “menor”: o overflow também precisa ser considerado. É por isso que LT usa N != V.

mov r0, #0
subs r0, r0, #1

Depois da subtração, r0 = 0xFFFFFFFF, N vale um, Z vale zero, C vale zero porque houve empréstimo e V vale zero porque -1 cabe com sinal.

cmp e tst atualizam flags sem exigir um s escrito no final. Já sub e subs são formas diferentes. ldr, str e mov comum não apagam automaticamente o resultado de uma comparação anterior.

A condição sempre observa as flags mais recentes, não necessariamente a comparação visualmente mais próxima no código. Uma instrução com s entre cmp e bne pode mudar o significado do desvio. Uma chamada de função também pode modificar flags; não dependa delas depois de chamar uma rotina sem uma convenção explícita.

CMP e TST

cmp a, b atualiza NZCV como se calculasse a - b, mas descarta o resultado numérico. Os dois operandos permanecem intactos.

cmp r1, #20
blo sem_dinheiro
sub r1, r1, #20

Se r1 for menor que 20 sem sinal, a execução vai para o label sem_dinheiro. Caso contrário, segue e subtrai o custo. A comparação sozinha não implementa um bloco if: o desvio ou uma instrução condicional utiliza seu resultado.

tst a, mascara atualiza as flags lógicas como um AND, sem guardar o AND em um registrador. Usamos principalmente Z para saber se algum bit selecionado estava ligado:

tst r1, #16
bne direita_pressionada

Isso verifica o bit 4. Com uma máscara que possui vários bits um, resultado diferente de zero significa pelo menos um desses bits ligado, não necessariamente todos. Para testar todos, faça o AND em um destino e compare com a máscara.

cmpeq é uma comparação condicional. O padrão abaixo verifica se as duas coordenadas coincidem com um ponto:

cmp r0, #6
cmpeq r1, #2
bne fora_do_ponto

Se X não é 6, a segunda comparação não executa e o primeiro resultado diferente continua valendo. Se X é 6, a segunda comparação decide se Y é 2. Assim, o desvio acontece se qualquer coordenada estiver diferente.

Condições

No estado ARM, as instruções usadas aqui podem receber códigos de condição. A mesma condição aparece em bne, movne, strne ou bxne: o efeito da instrução só ocorre quando as flags satisfazem o código.

Considere r0 = 0xFFFFFFFF e cmp r0, #0: bhi seria tomado porque o valor é maior sem sinal; blt também seria tomado porque o valor representa -1 com sinal. Não há contradição: são interpretações diferentes dos mesmos bits.

Nos exemplos de movimento com coordenadas negativas temporárias, usamos condições com sinal. No Tower Defense, certas verificações de faixa usam uma comparação sem sinal que também rejeita -1, pois ele aparece como um valor enorme nessa interpretação.

Uma condição falsa evita o efeito da instrução, mas não significa custo zero de execução. Não estime o tempo de um quadro apenas contando comandos que mudam valores.

B e labels

b destino muda o fluxo para o label indicado, sem criar um endereço de retorno em lr. A forma condicional, como bne, só desvia quando a condição é verdadeira. Sem desvio, a execução segue para a instrução seguinte.

mov r2, #3
repeat:
    subs r2, r2, #1
    bne repeat

O decremento acontece três vezes. O programa não reconhece uma estrutura especial de laço: reconhece subtrações, flags e mudanças no fluxo.

O GNU assembler também oferece labels numéricos reutilizáveis:

    b 1f
1:  mov r0, #3
2:  subs r0, r0, #1
    bne 2b

1f procura a próxima definição de 1: à frente; 2b procura a definição mais recente de 2: para trás. O b em 2b significa backward, não o botão B. Esses nomes são resolvidos pelas ferramentas antes da execução.

Um label nomeado não cria automaticamente um escopo de função. Se o código não desviar ou retornar, ele pode continuar executando o que estiver depois desse label. A regra dos labels locais está na documentação do GNU assembler.

BL e BX

bl rotina desvia e coloca em lr o endereço para continuar depois da chamada. No estado ARM usado aqui, esse retorno aponta para a instrução seguinte ao bl. A rotina costuma retornar com bx lr.

double_value:
    add r0, r0, r0
    bx lr

Esse fragmento dobra o valor em r0 e volta ao chamador. Não existe um objeto de função protegendo os registradores: o contrato precisa dizer o que entra, o que sai e o que pode ser alterado.

bx registrador salta para o endereço contido no registrador e pode trocar o estado ARM/Thumb conforme o bit 0 do destino. Ele não cria um retorno em lr. Os endereços de código e o estado escolhido precisam respeitar o alinhamento correspondente.

Uma rotina que chama outra com bl sobrescreve seu próprio lr. Por isso, quando precisa voltar ao chamador original, deve preservá-lo, normalmente na pilha. Já b fill_rect, no final de paint_hero, encaminha a execução sem substituir lr: fill_rect retorna diretamente ao chamador de paint_hero.

blne new_game é uma chamada condicional. bxne lr é um retorno antecipado condicional. Nenhum deles faz por conta própria uma comparação; ambos usam as flags existentes.

PUSH e POP

A pilha fica na RAM e é controlada por sp. Nos exemplos, ela cresce para endereços menores. push reserva espaço e escreve os registradores; pop lê os valores e devolve esse espaço.

outer:
    push {r4, lr}
    mov r4, #20
    bl inner
    pop {r4, lr}
    bx lr

Se sp era 0x03007F00, o push de dois registradores o leva a 0x03007EF8. A lista ocupa oito bytes, quatro por registrador. Em endereços crescentes ficam r4 e depois lr; a ordem é determinada pelos números dos registradores, não por uma ideia de “copiar o texto da lista para trás”. O pop correspondente restaura os valores e o ponteiro original.

No ARM, essas formas são representadas por operações de armazenamento e carga múltiplos, equivalentes aos padrões stmdb sp! e ldmia sp!. {r5-r8, lr} representa cinco registradores, portanto 20 bytes.

Todos os caminhos de retorno precisam restaurar o que foi empilhado. Retornar antes do pop deixa a pilha desequilibrada. Além disso, a lista deve preservar o que o contrato da rotina exige, não apenas lr.

Os exemplos têm convenções locais, incluindo passagem da cor em r4. Isso não é o contrato padrão de qualquer função C. Ao misturar linguagens, respeite a ABI escolhida, inclusive os registradores preservados e o alinhamento de oito bytes da pilha nas interfaces públicas AAPCS. Não presuma que toda chamada interna desta série já foi escrita para essa integração.

MRS e MSR

mrs lê um registrador de status para um registrador comum. msr escreve campos selecionados desse status. São operações sobre o estado da CPU, diferentes de escrever em um registrador de vídeo por um endereço de memória.

mrs r0, cpsr
msr cpsr_c, #0xdf

No startup dos exemplos, msr cpsr_c, #0xdf define o campo de controle: modo System, estado ARM, IRQ e FIQ mascaradas. Os cinco bits inferiores de 0xDF valem 11111, o código do modo System; os bits I e F valem um. O bit T vale zero.

O sufixo _c seleciona o campo de controle, não as flags NZCV. Escrever esse campo exige o contexto de privilégio apropriado. Os programas usam polling e não instalam tratadores de interrupção; copiar esse startup para um programa que depende de IRQ pode impedir que ele funcione.

Não use msr para alternar casualmente entre ARM e Thumb: a troca de estado segue os mecanismos apropriados, como bx. A instrução acima é uma configuração inicial no estado ARM.

Diretivas do assembler

As diretivas orientam o GNU assembler. Algumas selecionam a linguagem, outras definem símbolos ou colocam dados em seções. Elas não são operações que a CPU executa como uma soma ou uma leitura.

Uma constante de hardware e uma variável têm papéis diferentes:

.equ KEYINPUT, 0x04000130
.section .bss
.balign 4
.global coins
coins: .space 4

KEYINPUT é um nome para um endereço já determinado pelo hardware. coins marca quatro bytes que o linker vai posicionar na RAM. Nesse projeto, a BSS é NOLOAD; reservar esse espaço não faz a CPU preenchê-lo com zero. O boot precisa limpar as variáveis.

.ltorg é importante quando ldr =valor depende de um literal alcançável pelo código. Literais são dados: não deixe o fluxo cair diretamente sobre eles. Nos exemplos, um retorno ou um desvio encerra o caminho de execução antes da área emitida.

As condições de montagem também são diferentes das condições do jogo. .if LESSON >= 2 escolhe o que entra no arquivo antes de a ROM existir. cmp seguido de bne decide algo durante a execução. Consulte as diretivas ARM e o manual geral do assembler para outras formas.

Linker e cabeçalho

O assembler cria instruções, dados e referências. O linker organiza essas partes e resolve endereços entre seções e arquivos.

O ponto . usado no script do linker representa sua posição de organização. Não é o mesmo que o ponto que inicia uma diretiva do assembler, embora os arquivos usem notações parecidas.

O cabeçalho é um requisito do formato de cartucho GBA. Reservamos seus bytes no começo da ROM, deixamos uma instrução de desvio na entrada e usamos rom.py para preencher seus campos e checksum. ENTRY(_start) sozinho não faz o console procurar um símbolo textual: no arquivo binário, o hardware encontra bytes e instruções em posições específicas.

O nome .header é uma convenção do projeto; quem a coloca na posição adequada é o linker. O código Python de cabeçalho roda no computador de desenvolvimento. Nenhum comando do linker ou do Python vira automaticamente uma instrução executada pela CPU do GBA. A documentação de SECTIONS do GNU ld detalha essa organização.

Ferramentas de construção

Os nomes abaixo são comandos do terminal, não comandos da linguagem Assembly:

-mcpu=arm7tdmi seleciona o alvo. -g inclui informações úteis para depuração. -o escolhe o arquivo de saída. -T gba.ld seleciona o script do linker. No Tower Defense, --defsym LESSON=2 define um símbolo na montagem para escolher uma etapa.

O .elf conserva informações que ajudam a entender os endereços e nomes. O .gba contém o cartucho que abrimos no emulador. Mudar o .s sem repetir a construção não altera uma ROM antiga que continua no disco.

SWI e BIOS

swi provoca uma exceção de software. No GBA, serviços da BIOS podem ser chamados por esse mecanismo, seguindo a convenção de identificação do serviço, argumentos e estado ARM ou Thumb apropriados. Não é uma chamada de sistema operacional de um computador pessoal.

Nenhum dos seis exemplos depende de chamadas swi: a espera de vídeo é feita por consulta a VCOUNT. Um serviço da BIOS que aguarda interrupções exige que a configuração correspondente esteja preparada. Não substitua uma espera por polling por uma chamada de BIOS sem verificar esses requisitos.

O primeiro passo para experimentar BIOS deve ser um programa pequeno, com a convenção da função documentada e um resultado observável. A referência de instruções explica como a exceção é solicitada; a documentação da plataforma explica o serviço que a atende.

Outras instruções ARM7TDMI

Estas famílias complementam as que aparecem nos tutoriais. A tabela é um mapa para consulta posterior, não uma recomendação para acrescentar todas ao primeiro jogo.

O ARM7TDMI não tem sdiv, udiv, movw, movt, blx ou os blocos it de arquiteturas posteriores. Divisão exige uma rotina, um serviço apropriado da BIOS ou uma transformação matemática válida para o caso. Para chamar alternando ARM e Thumb nesta CPU, use os padrões de interworking adequados a ARMv4T.

Não existe uma instrução dedicada nop no núcleo ARMv4T com a codificação moderna de NOP. O assembler pode aceitar a grafia e emitir uma operação equivalente, como um movimento de um registrador para ele mesmo. Conferir o alvo e a desmontagem evita confundir a sintaxe aceita pela ferramenta com uma nova capacidade da CPU.

Exemplo comentado

Leia este fragmento supondo que coins já foi definido na RAM e contém 20:

spend_once:
    ldr r0, =coins
    ldr r1, [r0]
    cmp r1, #5
    bxlo lr
    sub r1, r1, #5
    str r1, [r0]
    bx lr

Se o saldo inicial fosse 3, a rotina retornaria antes da subtração. Ela não preserva r0, r1 ou as flags e não informa sucesso em um registrador separado: essas escolhas fazem parte do contrato deste fragmento.

Esse exercício reúne a distinção essencial da série: uma constante pode representar um endereço, um registrador pode conter esse endereço, e uma instrução com colchetes acessa o conteúdo da memória. Em um endereço de I/O, essa mesma operação interage com o hardware.

Erros frequentes

Referências oficiais

O ARM7TDMI Technical Reference Manual, DDI 0210C descreve o modelo da CPU e resume as instruções. Use a parte de instruções ARM e condições, observando a arquitetura do alvo. Folhas de referência de ARM mais recente podem incluir operações inexistentes no GBA.

O manual do GNU assembler para ARM define a sintaxe da ferramenta usada aqui; suas páginas de diretivas e símbolos e labels locais ajudam a interpretar o texto do programa. O manual de scripts do GNU ld trata da ligação.

Para continuar aprendendo por experiências executáveis, volte ao índice dos nove capítulos. Para aplicar as operações em uma partida, siga o artigo principal de Tower Defense.