O que há de errado com variáveis ​​públicas?

33

Code Bots

Eu odeio variáveis ​​privadas e protegidas. Eu só quero acessar tudo e qualquer coisa!

Se você é como eu, então este desafio é para você!

Escreva um bot que funcione em harmonia com outros bots e faça com que outros façam o que quiser. Você é um programador e sabe como as coisas devem funcionar. Seu trabalho é converter o maior número possível de bots para os seus caminhos.

O código

Você terá 24 linhas de código para escrever seu bot. A cada turno, cada bot executará 1 linha sequencialmente.

Cada bot armazena 5 variáveis Aatravés E. Ae Bsão para uso pessoal, Carmazena a próxima linha a ser executada, Darmazena a direção atual e Eé um número aleatório. As variáveis ​​começam em 0, exceto D, que começará com um valor aleatório. Todas as variáveis ​​têm apenas o armazenamento de 0 a 23. Números maiores ou menores serão modulados por 24.

Neste post, usarei o oponente para ser o bot adjacente que você está enfrentando

Cada linha deve conter um dos 5 comandos a seguir:

  1. Flagfaz nada. Exceto que é como você ganha
  2. Movemove seu bot na Ddireção th. Se um bot já ocupa o espaço, nenhum movimento acontecerá
  3. Copy Var1 Var2 copia o conteúdo de Var1 para Var2
  4. If Condition Line1 Line2 Se Condição for verdadeira, executa Linha1, caso contrário Linha2
  5. Block Var1 bloqueia a próxima gravação em uma variável

Uma variável pode ser usada da seguinte maneira:

#Varusará a variável como um número de linha. Se Afor 17, Copy #8 #Acopiará o conteúdo da linha 8 para a linha 17. *Varusará a variável do seu oponente. Copy 5 *Cirá definir a Cvariável do oponente para 5 Var+Varadicionar as duas variáveis. Copy D+1 Dgirará o bot para a direita

Quando Dé usado como uma direção, [North, East, South, West][D%4]será usado

Esses modificadores podem ser encadeados: Copy *#*C #9copiará a próxima linha que seu oponente executará em seu próprio código na linha 9. **Drefere-se à Dvariável do oponente de seu oponente .

Uma condição será avaliada da seguinte forma:

  1. Se Var:
    1. Se Var é Aatravés C, ele irá retornar true se Var é diferente de zero, o mais falso.
    2. Se Var for D, ele retornará true se houver um bot na Ddireção th, caso contrário false
    3. Se Var for E, retornará true se E for ímpar, caso contrário false
    4. Se Var for uma linha, retornará true se for uma linha Flag.
  2. Se Var1=Var2:
    1. Retorna verdadeiro se ambos são A-Ee é igual ao mesmo número
    2. Retorna true se ambas são linhas e o tipo de linha é igual
  3. Se Var1==Var2:
    1. Retorna verdadeiro se ambos são A-Ee é igual ao mesmo número
    2. Retorna true se ambas são linhas e são idênticas (sinalizadores de bots diferentes não serão iguais)

50 bots de cada tipo serão colocados em um mundo toroidal no seguinte padrão:

B...B...B...B...
..B...B...B...B.
B...B...B...B...
..B...B...B...B.

Após cada jogo de 5.000 turnos, as bandeiras de cada bot serão contadas. Você ganha um ponto se um bot tem mais sua bandeira do que qualquer outro tipo de bandeira. Se houver empate entre os Nbots, nenhum ponto será dado.

Serão 10 jogos e as pontuações serão acumuladas no final.

Notas laterais

Comentários de fim de linha são permitidos e são indicados com //

Tentar fazer algo que não faz sentido, como adicionar a uma linha, não fará nada

Tentar fazer algo em um bot inexistente não fará nada

A recursão infinita em um Ifterminará sem que nenhuma linha seja executada

If não altera o valor de C

A Blocknão expira até que alguém tente escrever nele

Várias variáveis ​​e linhas podem ser bloqueadas ao mesmo tempo

BlockA execução de uma variável várias vezes bloqueará várias vezes, desde que a segunda instrução de bloco esteja em uma linha de código diferente da sua primeira

Espaços são permitidos apenas entre argumentos (e após o comando)

Se um bot for menor que 24 linhas, Flag será o restante das linhas.

Programa de amostra

Copy 2 C        //Skip to the If line
Flag            //Where I'm storing my flag
Move            //Move in the D'th direction
If D #5 #2      //If there's a bot, copy code, otherwise, move!
Copy #1 *#E     //Copy my flag onto a random spot in my bot's code
Copy 2 C        //Skip back to the If line

O programa será executado pelo meu controlador Python aqui .

O controlador Java está aqui É rápido e parece muito melhor que o python.

Placar:

  1. 6837 $ Copiar
  2. 3355 Lockheed
  3. 1695 MindControl
  4. 967 Bizantino
  5. 959 AttackOrElse
  6. 743 Cadmyllion
  7. 367 Gripe
  8. 251 TheCommonCold
  9. 226 Magus
  10. 137 HideBlockAttack
  11. 129 RowBot
  12. 123 FastMoveCloneDodge
  13. 112 FastForwardClone
  14. 96 QuickFreeze
  15. 71 RepairAndProtect
  16. 96 SuperFreeze
  17. 93 RovingVirus
  18. 80 ForwardClone
  19. 77 FreezeTag
  20. 68 Palimpseste
  21. 62 BlockFreezeAttack
  22. 51 RushAttackDodge
  23. 46 Bloqueador
  24. 40 TurretMaker
  25. 37 Copycat
  26. 37 Kamikaze
  27. 35 FlagInjector
  28. 33 RandomCopier
  29. 31 insidioso
  30. 29 HappyAsAClam
  31. 25 NanoVirus
  32. 21 Nullifier
  33. 19 Nanoviris
  34. 17 BoringCopybot
  35. 16 Movebot
  36. 14 Flagbot
  37. 13 Neutralizador
  38. 12 Câncer
  39. 9 DNAbot
  40. 9 Parasita
  41. 8 MetaInsidious
  42. 8 Rebranding
  43. 8 AdaptiveBot
  44. 8 ReproduzindoBot
  45. 8 KungFuBot
  46. 5 QuickFreezerbot
  47. 4 Atacante
king-of-the-hill 
— Nathan Merrill
fonte
1
Eu falarei sobre isso assim que o Java estiver disponível para eu testar.
— Wasmoo
2
Suponho que você nunca jogou a guerra do núcleo. en.wikipedia.org/wiki/Core_War
— matt_black 28/08
Eu não joguei, mas li bastante enquanto escrevia esse desafio.
— Nathan Merrill
Eu tenho um patch para o controlador Python e tentei enviá-lo de volta para você no github ... mas não tenho permissões / realmente não conheço o git. O patch substitui todos os "16" s por "num_lines" para permitir acesso de gravação / salto às últimas 8 instruções; também remove "max_flag_count = 0" da condição de empate em declare_flags (), que às vezes concedia um empate de mão dupla a um terceiro bot.
— adipy
1
Algum ETA quando a próxima rodada de batalha for executada? Sem pressa. Eu só estou curioso. Obrigado.
— COTO

Respostas:

13

Flagbot

Flag

Por que se preocupar em fazer alguma coisa quando outros bots serão bons o suficiente para me fornecer seu código?

— Sparr
fonte
8

Congelar tag

Move
If D #3 #2
Copy 23 C
Copy 3 C
Copy #23 *#*C
Copy #21 *#*C+1
Copy #22 *#*C+2
Copy #21 *#*C+3
Copy #22 *#*C+4
Copy #21 *#*C+5
Copy #22 *#*C+6
Copy #21 *#*C+7
Copy #22 *#*C+8
Copy #21 *#*C+9
Copy #22 *#*C+10
Copy #21 *#*C+11
Copy #22 *#*C+12
Copy #21 *#*C+13
Copy #22 *#*C+14
Copy D+1 D
Copy 0 C
Flag
Flag
Copy C+23 C

Prenda o oponente em um loop, encha-o de bandeiras e passe para o próximo oponente.

— Sparr
fonte
Copy C+23 CEssa deve ser a linha de código mais maliciosa xD.
— Cruncher
Estou interessado. Isso pode ser improvável. Em vez de preenchê-los com bandeiras, você pode colocar um loop nelas que se enchem de bandeiras? Ou isso não contaria como suas bandeiras?
— Cruncher
Essa é uma ideia pura e viável, mas mais complicada. Você deve escrever um bot que usa-lo :)
— Sparr
2
Você sabe a resposta para a última pergunta? Or would that not count as your flags?. Porque se eles não contam como suas próprias bandeiras, definitivamente não é uma boa solução
— Cruncher
@Cruncher, você poderia dar a eles uma de suas bandeiras e fazê-las copiá-las, o que contaria como uma das suas.
— Sparr
8

Parasita

Por que matar outros bots? Este bot examina o código do oponente e substitui apenas as bandeiras.

Copy 1 A
Copy E D
Block #A
If *#A #C+3 #C
Copy A+A+A+A+A A
Copy C+19 C
Copy #C+4 *#A
Flag
Copy 1 A
Copy E D
Block #A
If *#A #C+3 #C
Copy A+A+A+A+A A
Copy C+19 C
Copy #C+4 *#A
Flag
Copy 1 A
Copy E D
Block #A
If *#A #C+3 #C
Copy A+A+A+A+A A
Copy C+19 C
Copy #C+4 *#A
Flag
— PhiNotPi
fonte
8

$ Copiar

Esse bot usa muitas das mesmas técnicas que a Lockheed da COTO, então eu emprestarei e aprimorarei descaradamente.

Isso explora uma Cvulnerabilidade para quebrar blocos e até reverte o neutralizador. Também está escrito em absolutos por causa disso. Acho que isso pode ser interrompido se a Cmudança for restabelecida, mas, enquanto a mudança for constante, ela poderá ser reescrita para combatê-la.

Por qualquer motivo, a falta de loop no final tornou esse bot super bom.

Block #C+A 
If D #7 #13        //If [enemy] Copy 0 ELSE block
If D #8 #0         //If [enemy] Freeze 0 ELSE block
If D #9 #6         //If [enemy] FreezeCheck ELSE Inc
Move
Copy 0 C
Copy A+5 A          //Inc
Copy 23 *C          //Copy 0
Copy #10 *#*C+23    //FreezeAttack
If *#*C==#10 #11 #5 //FreezeCheck: If [frozen] GOTO Copy Attack ELSE GOTO [1]
Copy C+23 C         //FREEZE
Copy 13 C           //GOTO Copy Attack
Copy 15 C           //Loop Copy Attack
Block #C+A
Copy D+3 *D             //Copy Attack: Spin Enemy
Copy 0 *B               //Set enemy counter (a la COTO)
Copy #*B+0 *#*C+*B+1    //Copy my lines
Copy #*B+1 *#*C+*B+2    //Copy my lines
Copy #*B+2 *#*C+*B+3    //Copy my lines
Copy *B+3 *B            //Inc counter
If *B==0 #19 #12        //Loop check
Copy D+1 D              //Turn myself
— Wasmoo
fonte
1
Vou me curvar ao seu design aprimorado e encará-lo novamente na competição Bots v. 3. ;)
— COTO
Sinceramente, acredito que este foi um esforço de grupo da parte de todos. Isso não existiria se não fosse por vários bots por aí para modelar. Curiosamente, a adição desse bot reorganizou completamente o placar, pois os bots que dependiam do bloqueio foram quebrados, enquanto outros que dependiam da substituição da bandeira subiram.
— Wasmoo 4/04
Alguém pode resumir, em algum lugar, o comportamento real de Block e como esse bot e a Lockheed se aproveitam disso?
— Sparr
Cada linha pode acumular blocos, conforme descrito por HappyAsAClam . Mais importante ainda, ele não empilha para blocos chamados com os mesmos Cvalores. Assim, um bloco pode ser empilhado quando chamado de uma Ifinstrução, que é a exploração que está sendo usada aqui. $ Copy quebra blocos (como o molusco) executando Copyna mesma linha repetidamente até obter êxito, o que lhe dá uma vantagem sobre a Lockheed.
— Wasmoo 11/09/14
7

Lockheed

Minha terceira (e provavelmente final) submissão a essa guerra bot em particular: o Lockheed Reactor, ou "Lockheed", para abreviar.

Block #C+A
If D #C+7 #C+1
Block #C+A
Move
Copy A+5 A
If A==0 #C+12 #C+21
Copy C+17 C
Copy D+3 *D
Copy C+9 C
Copy C+21 C
Copy C+23 C
Copy #C+23 *#*C+2
Copy #C+22 *#*C+1
Copy 0 *A
Copy #*A+C+9 *#*C+*A+1
Copy *A+1 *A
If *A==0 #C+15 #C+17
Copy D+1 D
Copy C+5 C

Agradecimentos especiais a @Wasmoo, que compartilhou sua descoberta do "'Bloquear uma variável várias vezes bloqueará várias vezes, desde que a segunda declaração de bloco esteja em uma linha de código diferente da sua primeira.' simplesmente não é verdade "exploração. Faço uso extensivo disso.

Agradecemos também a Nathan Merill por administrar a competição e por publicar o simulador. O simulador é totalmente inestimável no ajuste de bots. Eu não teria acreditado se não tivesse simulado com meus próprios olhos, mas a adição ou remoção do recurso bot mais conceitualmente menor pode significar a diferença entre grande sucesso e falha abjeta. Estou dividido quanto a isso ser bom ou não.

— COTO
fonte
O bloqueio de uma variável várias vezes falha. No entanto, ele só falha ao bloquear se: Você está executando a mesma linha (um Ifapontador para essa linha não falhará), você está bloqueando o mesmo valor (uma única linha pode bloquear as linhas de 1 a 24 com uma variável incremental) e o bloco ainda não foi lançado (alguém tentou modificar essa variável)
— Nathan Merrill
Eu contesto a instrução no OP porque a instrução de bloco está codificada para o IP, não a instrução de bloco. Assim, uma única instrução de bloco pode instituir até 24 blocos separados em todas as instruções. Eu afirmo que a cláusula no OP afirmando "desde que a segunda declaração do bloco esteja em uma linha de código diferente da sua primeira" deve ser alterada para "enquanto o bloco do par ( C, <block target>) ainda não estiver em vigor". Ou seja, a linha na qual a instrução do bloco está não tem relevância para o empilhamento, exceto que, se o bloco for executado diretamente, C= endereço da instrução do bloco.
— COTO
1
Este bot é incrível! Ele combina todos os melhores conceitos em um. Ele se protege até encontrar um inimigo, congela-o duas vezes e carrega uma cópia de si mesmo no alvo antes de libertá-lo na direção oposta. Nas simulações, vi uma de suas cópias consertar um original que havia sido danificado. UAU! Bom trabalho, COTO!
— Wasmoo 3/09/14
6

Ataque ou outro

Vendo que robôs defensivos como o bizantino estavam indo tão bem, decidi fazer um robô defensivo também.

Isso tem dois conjuntos de padrões, dependendo da presença ou não do inimigo.

  • Se o inimigo não estiver presente, ele bloqueia suas linhas por 3 turnos e depois se move.
  • Se o inimigo estiver presente, ele alterna entre copiar sua bandeira e código de cópia que fará com que o inimigo copie essa bandeira (um replicador fraco) que copia sua bandeira
  • No final do loop, ele muda para uma direção aleatória e continua
  • A maioria dos aspectos de seu código é duplicada

Mais testes mostraram alguns conceitos importantes:

  • "Turn random" teve desempenho dramaticamente melhor que "Turn right" (+2700 em vez da alternativa)
  • O incremento de bloco A+7mostrado é mais eficaz do que qualquer outro incremento (+200 no próximo melhor)
  • "Ataque direto" mostrou-se melhor que "Replicador fraco" (+900 em alternativa)
  • Defesa de "3-1-2-1" melhor que outras combinações (+200 no próximo melhor)
  • O código duplicado de ataque, bloqueio e loop melhora sua pontuação (+300 em relação a não duplicada)
  • O incremento de bloco duplicado não melhora sua pontuação (+400 sobre duplicado)

Observar a simulação graficamente através da interface do usuário Java ajudou muito. Obrigado! Abaixo está o código novo e aprimorado. Acho que não posso fazer mais nada.

Block #C+A          //Dynamic block for If statements
If D #20 #0
If D #19 #8
If D #20 #23
If D #19 #0
If D #20 #8
If D #19 #23
Copy A+7 A          //Increment dynamic block
Block #C+A          //Dynamic block for If statements
If D #19 #8
If D #20 #0
If D #19 #8
If D #20 #23
If D #19 #8
If D #20 #0
If D #19 #23
Copy E D            //Turn Random
Copy 23 C           //Loop to beginning
Copy 23 C           //Loop to beginning
Copy #22 *#*C+1     //Copy my flag to the enemy's next
Copy #21 *#*C+1     //Copy my flag to the enemy's next
Flag
Flag
Move
— Wasmoo
fonte
Este bot foi realmente incrível. E você é bem-vindo à GUI.
— Nathan Merrill
Atualizei-o para incluir um segundo loop, que melhorou drasticamente seu desempenho. Também notei que o bloqueio em Java é baseado no Cque o bloqueou. Como este bot possui um bloco rotativo baseado em C, ele acumulará vários blocos em cada um de seus comandos. Isso torna esse bot ainda mais defensivo.
— Wasmoo
Meu entendimento é que apenas um bloco por instrução de origem pode ser estabelecido; portanto, o código acima pode estabelecer um único bloco em qualquer instrução (e levaria 24 * 17 voltas para estabelecer um único bloco em cada instrução). Se meu entendimento estiver errado, o idioma "Bloquear uma variável várias vezes bloqueará várias vezes, desde que a segunda declaração de bloco esteja em uma linha de código diferente da sua primeira". no OP precisa ser emendado, porque esta declaração é (francamente) falsa se o código do Wasmoo for capaz de estabelecer vários blocos em qualquer instrução.
— COTO 02/09
@COTO: O simulador Java adiciona um bloco por Iflinha a uma lista, digitando a Cvariável que o chamou. Assim, com os 1 bloco e os 9 Ifs que executam a instrução Block, o bot pode obter até 10 blocos para cada linha (fazendo pelo menos 24 * 10 * 10 turnos). Talvez o OP não tenha transmitido a simulação corretamente.
— Wasmoo 02/09
Atualizei o código novamente para refletir ainda mais as iterações, mantendo o conceito principal. Eu pensei que isso seria melhor do que inundar o fórum com cada iteração, como a mudança de Replicação Fraca para Ataque Direto e Não-Duplicado para Duplicado. Se você gostaria que eu republicasse meu original, eu posso fazê-lo.
— Wasmoo 02/09
5

Row Bot

Move
If D #7 #0
If D #7 #0
If D #7 #0
If D #7 #0
If D #7 #0
Copy 0 C
If D=*D #9 #8     //If they point in a different direction
Copy *D D           //fix that
If #A==*#A #10 #11  //Did we copy line A already?
Copy A+1 A          //If so, A++
Copy #A *#A         //else, copy it!

Vai se mover até encontrar um robô.
Irá definir esse robô na mesma direção que ele.
Em seguida, copiará seu código no robô.
Isso deve criar uma linha de robôs "Row Bot". :)

— MegaTom
fonte
Existem dois problemas (facilmente corrigíveis). Primeiro, as Ifdeclarações devem ser capitalizadas. Segundo, não deve haver espaços em nenhum dos lados do =, como D=*D.
— PhiNotPi
Essa é uma ideia incrível.
— Sparr
Sem uma bandeira, você não vai ganhar.
— Pa Elo Ebermann 29/08/14
3
Os bots do @ PaŭloEbermann são preenchidos com sinalizadores de até 24 linhas, portanto esse bot tem 12 sinalizadores implícitos no final.
— Sparr
5

Super Freeze

Move                    // start moving!
Block #E
If D #12 #0             // 8 turns of attack or move
If D #12 #0
If D #12 #0
If D #12 #0
If D #12 #0
If D #12 #0
If D #12 #0
If D #12 #0
Copy D+1 D              // change direction
Copy 0 C                // start over
If *#*C==#23 #13 #14    // if opponent is frozen, give them a flag, otherwise freeze them
Copy #C+13 *#E          // give a flag to opponent
Copy #23 *#*C           // copy freeze line to opponent
Flag                    // 8 flags, one per If above
Flag
Flag
Flag
Flag
Flag
Flag
Flag                    
Copy C+23 C             // this line freezes any bot that executes it

Esse bot continua tentando congelá-lo na frente dele até que funcione, depois escreve um monte de bandeiras em linhas aleatórias e, após 8 turnos, ele gira e passa para outro oponente.

— Sparr
fonte
5

bizantino

Um bot altamente defensivo que institui vários blocos em suas bandeiras e instruções mais sensíveis, incluindo meta-blocos (isto é, blocos em instruções críticas de bloco).

Ele também se move constantemente de maneiras imprevisíveis e planta bandeiras em vários locais dos oponentes, com base no melhor esforço.

Block #A
Block #A+1
Block #A+2
Copy E D
Move
Block #A+3
Block #A+4
Move
Copy #22 *#*C+1
Copy E D
Move
Block #A+5
Block #A+6
Block #A+7
Move
Copy #22 *#23
Block #A+8
Block #A+9
Block #A+10
Copy #22 *#2
Copy A+14 A
Move
Flag
Copy #22 *#*C+12

Não tenho certeza de como será o desempenho, pois não posso simular. Mas vamos tentar. ;)

aviso Legal

Escrevi isso antes de ser gentilmente informado pelo PhiNotPi que a lógica condicional é gratuita. No entanto, decidi deixá-lo, pois nunca se pode ter muitos bots.

— COTO
fonte
este bot está ganhando!
— justhalf
4

Cadmyllion

"Acabei de entrar em um bot no battle royale", eu digo. "Ele se move a cada poucas voltas para evitar ataques de bots mais lentos."

"O que você quer dizer com bots mais lentos?" PhiNotPi pergunta.

"Bots presos avaliando longas cadeias de lógica condicional", respondo.

"As instruções 'If' que redirecionam para outras instruções - incluindo outras instruções 'if' - são todas executadas no mesmo turno" ", diz PhiNotPi.

"Doces regras massacradas de código de montagem!" Eu choro. "Quem teve essa ideia?"

... e assim é a história de como o Cadmyllion surgiu.

Cadmyllion: o bot que explora alegremente a capacidade surreal de avaliar infinitamente muitas expressões condicionais em uma única instrução ... tornando praticamente tudo o que faz condicional.

Código

If D #15 #19
Move
If D #16 #20
Copy D+3 D
Block #A
If D #15 #20
Copy A+1 A
If D #16 #1
Move
If D #15 #19
If D #16 #4
Copy E D
Block #A+12
Copy C+10 C
Flag
If *#0==#14 #17 #21
If *#0==#14 #18 #21
If *#*C+1==#14 #18 #22
Copy *C+11 *C
Block #A+6
Block #A+18
Copy #14 *#0
Copy #23 *#*C+1
Flag
— COTO
fonte
4

Meta Insidious

Esse bot congela e depois converte os oponentes em versões menos eficientes do Sparr's Insidious , que por sua vez transformam os oponentes em bots que sinalizam spam para mim. Este é provavelmente o bot mais complexo que eu escrevi e, portanto, espero que seja terrível, não havia espaço para bloquear e apenas um sinalizador cabia no código. Transformar um bot em um clone insidioso também leva muito tempo.

O maior desafio foi escrever o código para os clones insidiosos de tal maneira que funcionasse independentemente da sua posição no bot. O congelamento é removido quando colo o penúltimo código exatamente onde o congelamento está localizado, isso inicia o oponente bem a tempo.

If D #2 #1
Copy 23 C
Copy #8 *#*C // freeze the opponent
Copy 9 A
Copy #A *#A+*C // copy the next line at the appropriate  line
Copy A+1 A
If A==0 #7 #23
Copy 23 C
Copy C+23 C
If D #C+2 #C+23 // the code for the Insidious clone starts here
Copy C+21 C
Copy C+2 C
If D #C+6 #C+22
If D #C+5 #C+22
If D #C+4 #C+20
If D #C+3 #C+19
If D #C+2 #C+18
Copy E D
Copy #C+7 *#*C
Flag
Copy C+3 A
Copy #C+22 #A
Copy A+1 A
Copy C+21 C // And ends here
— overactor
fonte
Essa é uma ideia inteligente. No entanto, não vejo nenhum comando Mover. Isso significa que nem o seu bot nem o seu spam serão movidos?
— Wasmoo
Os clones Insidious podem se mover dependendo do que está no código original do bots, devido ao espaço limitado, bastante funcionalidade q teve que ser descartada para tornar isso ainda possível com 24 linhas. Era mais um exercício mental do que qualquer outra coisa realmente.
— overactor
3

Reparar e proteger

Este bot repara seu próprio código, enquanto protege as linhas recém-reparadas.

If #A==#A+16 #C+1 #C
Copy #A #A+8
Block #A+8
Copy A+1 A
Copy E D
Move
Copy #C+1 *#*C
Flag
If #A==#A+16 #C+1 #C
Copy #A #A+8
Block #A+8
Copy A+1 A
Copy E D
Move
Copy #C+1 *#*C
Flag
If #A==#A+16 #C+1 #C
Copy #A #A+8
Block #A+8
Copy A+1 A
Copy E D
Move
Copy #C+1 *#*C
Flag

Explicação:

O valor inicial de Aé 0e as linhas são numeradas de 0 a 23. Se a Ifinstrução é executada e é falsa, ela tenta executar a mesma linha novamente. O controlador não permite que um bot execute a mesma linha duas vezes, então o turno termina e Cé incrementado para 1.

A próxima linha Copy #A #A+8é realmente executada independentemente do valor da Ifinstrução. A diferença é que ele é executado duas vezes se verdadeiro e uma vez se falso. Se a linha #A+8estiver bloqueada (o que acontece eventualmente), executá-la duas vezes com a cópia real, enquanto executá-la uma vez, apenas a desbloqueará. Em seguida, a linha recém-copiada é bloqueada para preservá-la.

— PhiNotPi
fonte
Estou tentando entender todos vocês, robôs, mas estou preso. Qual é o valor inicial de A? Não é 0? Nesse caso, sua primeira linha compara a linha 0 à linha 16, mas como eu entendi no bot de exemplo do OP, a primeira linha é a linha 1, não é? Além disso, ainda na sua primeira linha, #Crefere-se a essa mesma linha, o que significa que, se a Ifinstrução retornar false, você ficará preso em um loop infinito?
— plannapus
@ plannapus eu adicionei alguma explicação.
— PhiNotPi
3

Neutralizador

Esse bot faz com que a vítima reescreva todo o programa, valendo 0 pontos. Quando o vírus está no lugar, ele segue em frente. Esta é uma abordagem de terra arrasada para a vitória.

If D #C+2 #C+3          // A: If [enemy exists] B else C
Copy C+22 C             // GOTO A
If *#*C==#7 #C+4 #C+5   // B: If [enemy was neutralized] D else E
Move                    // C: Move
Copy E D                // D: Turn Randomly
Copy #7 *#*C            // E: Neutralize enemy
Copy C+1 C              // Skip the next line
Copy #C #C+1            // Neutralizing Code [Copy this line to next line]

A comparação *#*C==#7não parece se ajustar corretamente ao turno do oponente, mas o bot acaba seguindo em frente.

— Wasmoo
fonte
Copy C+1 Cé tudo o que é necessário para pular uma única linha.
— Nathan Merrill
2
'Pular a próxima linha' significa que seu bot passará 16 turnos executando instruções de sinalização antes de continuar. Em Copy 23 Cvez disso, você pode querer voltar para a primeira linha.
— Sparr
'Pular a próxima linha' só acontecerá se 'GOTO A' tiver sido substituído. Existem outras maneiras de tornar esse bot mais ofensivo e defensivo, como repetir 'A', duplicar o código e bloquear 'GOTO A'. No entanto, se esse bot for atingido, estará praticamente morto de qualquer maneira.
— Wasmoo 02/09
3

Insidioso

Move
If D #4 #0
If D #4 #0
Copy 0 C
Copy 4 C
If D #12 #11
If D #12 #11
If D #12 #11
If D #12 #11
If D #12 #11
Copy D+1 D
If D #4 #3
Copy #C+8 *#*C
Flag
Copy C A
Copy #C+22 #A
Copy A+23 A
Copy C+21 C

Inspirado pelo @Cruncher, este bot infecta outros bots com um pequeno bloco de código, preenchendo o outro bot com as bandeiras dele. Esses bots estão então patos para mais ataques, mas estarão cheios das minhas bandeiras quando forem infectados novamente por outra pessoa.

Edit: graças a @PhiNotPi pela assistência no golfe, @overactor por conselhos sobre eficiência

— Sparr
fonte
Parabéns por atingir 2k!
— precisa saber é o seguinte
3

Feliz como um molusco

Este é um exercício de bloqueio. Ele teve um desempenho notavelmente bom até $Copyaparecer.

O molusco possui 22 comandos de bloco. Como Aé alternado a cada loop, eles fazem referência a linhas diferentes a cada vez no loop. Isso permite que cada comando empilhe blocos em todas as outras linhas, atingindo no máximo 22 blocos por linha. Assim, para quebrar o molusco totalmente blindado, seria necessário escrever uma linha 22 vezes.

Por exemplo, #10será protegido sempre pelo loop pelas seguintes linhas:

  • Loop 0, A = 0 #10protegido pela linha 7 ( 7+0+3= 10)
  • Loop 1, A = 7 #10protegido pela linha 0 ( 0+7+3= 10)
  • Loop 2, A = 14 #10protegido pela linha 17 ( 17+14+3= 34 = 10)
  • Loop 3, A = 21 #10protegido pela linha 10 ( 10+21+3= 34 = 10)

Então, após a Linha 10 do Loop 3, #10foi bloqueada 4 vezes, exigindo 4 gravações #10para quebrar os blocos, com uma quinta para realmente substituir a linha.

Observe que os blocos são codificados por seu Cvalor e não serão empilhados se a linha protegida já estiver bloqueada pelo mesmo Cvalor. Portanto, após 22 blocos serem estabelecidos para cada linha, os blocos não serão mais empilhados.

Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Copy A+7 A
Flag
— Wasmoo
fonte
3

Controle mental

Eu acho que nunca é tarde demais?

Block #C+D
If D #2 #0        // Scan for enemy
If *#E==#E #0 #5  // Attack if necessary
Copy D+5 D        // Turn
Copy 22+1 C       // Repeat
Copy 4+1 C        // ATTACK:
Copy #22+1 *#*C   //   Freeze
Copy #17 *#17     //   Upload the DOWNLOADER
Copy #18 *#18     //
Copy #21 *#19     //
Copy D+2 *D       //   FACE ME!!
Copy 17 *C        //   Start download
If E #0 #13
If E #0 #13
Copy 22+1 C
Flag
Flag
Copy *#B+20 #B+20         // DOWNLOADER
If *#B+20==#B+20 *#20 #19 //
Copy 22+1 C               //
Copy 1+B B                //
Copy 16 C                 //
Flag
Copy 23+C C        // FREEZE

O MindControl vem da minha ideia de que levaria um tempo considerável para copiar todo o meu programa para o oponente, durante o qual meu bot está vulnerável a ataques de outras direções. Então, por que não fazer o oponente copiar meu programa enquanto eu procuro por inimigos?

Quando encontra um inimigo, o MindControl congela imediatamente o inimigo para impedir a fuga. Em seguida, ele carrega o downloader para o oponente e deixa a vítima fazer o download do programa do MindControl. O downloader explora o fato de que poucos bots usam Be fazem loop até baixar todas as 24 linhas. Quando o downloader reescreve #19de Copy 16 Cpara Copy 23 C, significa que a vítima baixou todas as linhas e continuará se reinicializando.

As primeiras versões do meu bot não incluem blocos. E era tão vulnerável que quase qualquer mudança é incapacitante. Então, decidi adicionar blocos com base no $ Copy do Wasmoo (que é baseado no Lockheed do COTO). A desvantagem que descobri é que é difícil para o original corrigir erros nas cópias. Mas isso está longe de prejudicar e a pontuação aumentou significativamente, por isso mantive os Blocks.

ATUALIZAÇÕES

Aprimorei o downloader para continuar tentando fazer o download até uma reescrita bem-sucedida para contornar os blocos. Isso significa que leva mais uma vez para carregar o downloader, mas minha pontuação dobrou após essa alteração! Não posso discutir com números.

Outra atualização. Como você deve ter notado, o MindControl decide se deve atacar o alvo comparando uma linha aleatória entre ele e o alvo. Se eles corresponderem, o MindControl apenas assume que o alvo já está infectado e o deixa em paz. (Nota: eu costumava usar uma linha estática para comparação, mas isso gera muitos falsos positivos e negativos). Acontece que isso fornece muitos falsos negativos. Então eu decidi explorar ==e fazer algumas mudanças triviais como C+23a 23+C. O programa é funcionalmente idêntico, mas diferente aos olhos de ==. Agora que o MindControl não possui uma linha idêntica a qualquer linha em qualquer outro bot, ele atingirá 100% qualquer bot intocado. Mais uma vez, a pontuação aumentou significativamente.

Melhorado o Downloader novamente. Agora ele roda em um loop mais curto. (que parece ter uma grande correlação com minha pontuação)

Downloader aprimorado mais uma vez. Usa o código do bot original para fazer o upload mais rápido. Também foram adicionados 2 blocos aleatórios que parecem melhorar a pontuação

— TwiNight
fonte
Nunca é tarde demais!
— Nathan Merrill
Estou pensando em renomear para fazer lavagem cerebral ...
— TwiNight
Ou BunkerBuster depois de assistir o busto downloader através HappyAsAClam o bunker
— TwiNight
Eu tinha pensado em tentar essa idéia de fazer upload de um downloader primeiro, mas não conseguia obtê-lo tão pequeno quanto você. Bom trabalho! Também adoro o uso de D como o delta do bloco móvel; ele salva um comando e acelera seu design. Estou surpreso que um bot sem o comando 'Move' funcione tão bem. As simulações mostram que os bots tendem a se aglomerar, mas eu não sabia que seria uma estratégia vencedora. E eu concordo, há algo exclusivamente satisfatório em quebrar o molusco.
— Wasmoo
@Wasmoo Obviamente, o design do downloader exige que o bot permaneça parado e isso faz com que os bots se agrupem. Eu gosto de pensar nisso como raízes de uma árvore que alcança e assimila outros bots para crescer. Mas acho que a agilidade é a razão pela qual $ Copy e Lockheed me venceram.
— TwiNight 19/09/14
2

Atacante

Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Flag
— Nathan Merrill
fonte
2

Movebot

Move
Copy 23 C
Flag

Como o Flagbot, mas mova-se enquanto aceita presentes de código para acompanhar todas as nossas bandeiras.

— Sparr
fonte
2

Reproduzindo bot

Esse bot tenta congelar seu oponente e, em seguida, copia todo o código nele antes de reiniciar o outro bot. Isso também deve funcionar (principalmente) se o oponente usar o bloqueio, embora isso torne tudo ainda mais lento do que já é.

If D #23 #22
Copy 23 C
Copy #18 *#*C
Copy #18 *#*C+1
Copy #18 *#*C
Copy #18 *#0
Copy #18 *#0
Copy 0 *C
Copy 0 *C
Copy 1 A
Copy #A *#*A
If D #12 #14
Copy A+1 A
Copy 9 C
Copy 23 C
Flag
Flag
Flag
Copy C+23 C
Copy D+1 D
Flag
If *#*C==#*C #19 #13
Move
If *#*C+1==#*C+1 #21 #13
— overactor
fonte
Nenhum espaço na condição #
— Nathan Merrill
@NathanMerrill gotcha
— overactor
2

Mago

Magus é uma tentativa simples de um vírus auto-propagador. Ele tenta se copiar nos programas de outros bots. (Editado para remover números negativos, corrigir condição, aparar linhas.)

Block #A
Copy #A *#A
Copy A+1 A
If A #0 #4
Copy 0 *C
Flag
Move
Copy 0 C
— Isaac
fonte
Valores negativos não são permitidos. Use 23 para B
— Nathan Merrill
Por favor, use 23, não 25.
— Nathan Merrill
A menos que eu estou mal-entendido, que faria com que ele não bloquear ou copiar linhas 23 ou 24 (nota: ele mudou um pouco desde a primeira revisão, A é incrementado por 1, não B)
— Isaac
0 = 24 + 1 = 25, -1 = 23. Se você quer que ele seja -1, deve ser 23.
— Nathan Merrill
Era assim antes, porque eu pensei que você pudesse comparar com 0 (perdi a parte '=' de alguma forma, eu culpo a desnatação), mas mudou agora, então A começa em 1 e termina em 25. Imagine a linha 3 como for (int i = 1; i < 25; i++).. .
— Isaac
1

DNAbot

Flag
Copy 8 D
Copy 16 B
If #D==#B #C+2 #C+3
Block #A
Copy #D #A
If D #7 #15
Copy #23 *#*C
Copy A+1 A
Copy B+1 B
Copy D+1 D
If #D==#B #C+2 #C+3
Block #A
Copy #D #A
If D #7 #15
Move
Copy A+1 A
Copy B+1 B
Copy D+1 D
If #D==#B #C+2 #C+3
Block #A
Copy #D #A
If D #7 #15
Flag

Este bot repara seu próprio código enquanto se move e ataca.

— Sparr
fonte
1

Freezerbot rápido

Tenta copiar bandeiras na linha que será executada próximo ao oponente, se move se não houver inimigo para atacar.

Block #13
Block #14
If D #13 #14
If D #13 #14
If D #13 #14
If D #13 #14   
If D #13 #14
If D #13 #14
If D #13 #14
If D #13 #14
If D #13 #14
If D #13 #14   
Copy 23 C
If E #15 #16
Move
Copy #23 *#*C
Copy D+1 D
— overactor
fonte
As duas primeiras linhas são inválidas. Eles precisam de # 13 e # 14 #
— Nathan Merrill
1

Bloco, Congelar, Ataque

Block #A        // start block loop
Copy A+1 A      // loop A from 0 to 23
If A #3 #4      
Copy 23 C       // repeat block loop
Copy 5 C        // exit block loop to attack/move loop
Move
If D #11 #5     // attack or move
Copy A+1 A      // loop A from 0 to 23
If A #9 #10
Copy 5 C        // repeat attack/move loop
Copy 23 C       // exit attack/move loop to block loop
Copy 11 C       // start of attack routine
Copy #23 *#*C   // freeze opponent
Copy #19 *#E    // copy flag to opponent
Copy #20 *#E    // copy flag to opponent
Copy #21 *#E    // copy flag to opponent
Copy #22 *#E    // copy flag to opponent
Copy D+1 D      // change direction
Copy 5 C        // repeat attack/move loop
Flag
Flag
Flag
Flag
Copy C+23 C     // freeze instruction, for copying

Bloqueia todas as 24 linhas e, em seguida, repete 24 vezes em movimento ou ataque, e repete. Um ataque envolve tentar congelar o oponente, copiar quatro bandeiras para locais aleatórios e depois virar.

— Sparr
fonte
1

Esconder, Bloquear, Atacar

Este bot é baseado no Block Freeze Attack. Alterei o posicionamento de algumas Ifinstruções para torná-lo mais compacto, permitindo que eu plantasse mais sinalizadores. Também tenho que fugir no início de um jogo para ganhar algum tempo para bloquear.

Copy D+1 D
Move           //buy some time by moving to a more secure location
Block #A+2
Copy A+1 A
If A #11 #17
Copy #23 *#E
Copy #22 *#E
Copy #21 *#E
Copy #20 *#E
Copy #19 *#E
Copy D+1 D
Copy 1 C
Move
If D #14 #15
Copy 3 C
Copy 11 C
Copy #18 *#*C
If D #16 #15
Copy C+23 C
Flag
Flag
Flag
Flag
Flag
— PhiNotPi
fonte
1

Vírus itinerante

If D #6 #16
Move
Copy 23 C
Flag
Flag
Flag
Copy 6 C
Copy A+23 A
Copy #A *#A                     //clone previous line to enemy
Copy 23 *C                      //freeze enemy
If A #6 #16                     //loop or turn then continue
Copy 0 *C                       //reboot enemy
Copy 23 C                       //start moving again
Flag
Flag
Flag
Copy D+1 D                      //turn
Flag
Flag
Flag
Flag
Flag
Flag
Copy 22 C                       //freeze instruction

Esse bot vagueia até encontrar um inimigo, congela-o, substitui todo o código pelo seu próprio, descongela-o e depois vagueia novamente.

— Sparr
fonte
1

O frio comum

Ele o infecta praticamente imediatamente e você o espalha. com base no Parasita do PhiNotPi , o resfriado comum verifica quase imediatamente se ele pode copiar sua bandeira sobre a sua. Bloqueia um valor aleatório, se não puder. Se move um pouco se não houver oponente.

Block #22
If D #8 #5
If D #8 #5
If D #8 #5
Copy 23 C
If E #6 #7
Copy D+1 D
Move
If *#E=#22 #15 #9
If *#E+1=#22 #16 #10
If *#E+2=#22 #17 #11
If *#E+3=#22 #18 #12
If *#E+4=#22 #19 #13
If *#E+5=#22 #20 #14
If *#E+6=#22 #21 #23
Copy #22 *#E
Copy #22 *#E+1
Copy #22 *#E+2
Copy #22 *#E+3
Copy #22 *#E+4
Copy #22 *#E+5
Copy #22 *#E+6
Flag
Block #E
— overactor
fonte
1

Gripe

Isso é baseado no resfriado comum (que foi baseado no meu parasita) com uma velocidade ligeiramente aumentada.

Move
Block #23
If D #8 #0
If D #8 #0
If D #8 #0
If D #8 #7
Copy 0 C
Copy D+1 D
If *#E #9 #10
Copy #23 *#E
If *#E+1 #11 #12
Copy #23 *#E+1
If *#E+2 #13 #14
Copy #23 *#E+2
If *#E+3 #15 #16
Copy #23 *#E+3
If *#E+4 #17 #18
Copy #23 *#E+4
If *#E+5 #19 #20
Copy #23 *#E+5
If *#E+6 #21 #22
Copy #23 *#E+6
Block #E
Flag
— PhiNotPi
fonte
Estou ansioso para ver o tipo de diferença que isso fará. Porém, o # 5 da linha 5 provocará um loop infinito, e é improvável que esses # 7 sejam exatamente o que você pretendia.
— overactor
@overactor Obrigado, esses foram erros criados pela adição de uma linha extra.
— PhiNotPi 29/08
Eu já conheci a dor?
— overactor
1

Rebranding

Move
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
Copy 0 C
If *#E=#14 #11 #9
If *#E==#14 #13 #12
Copy D+1 D
Copy #14 *#E
Flag

Este bot tenta localizar aleatoriamente bandeiras nos robôs inimigos e substituí-las por bandeiras amigáveis, afastando-se após detectar o sucesso. Inspirado por Cancer bot.

— Sparr
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.