Bem-vindo ao Code Bots 2!

Você aprendeu sua lição desde os últimos Code Bots. Você tentou descobrir mais maneiras de ajustar mais ações em menos linhas e agora finalmente consegue. Você fará um Code Bot orientado a eventos.

Seu bot deve consistir em 24 linhas. Cada linha segue um dos dois formatos:

Condition:Action

ou

Action

Seu bot também têm de armazenamento suficiente para armazenar 5 números inteiros nomeados Aatravés E. Um número inteiro pode armazenar valores de 0 a 23.

A cada turno, você executará a linha C, a menos que uma das condições seja verdadeira. Se sim, então Cconterá o número da linha do condicional verdadeiro e, em seguida, essa linha será executada. No final de cada turno, Cserá incrementado.

Existem as condições disponíveis:

1. Starté verdade apenas no primeiro turno. Você deve ter isso em seu código exatamente uma vez
2. BotAt(N) é verdadeiro se houver um bot no local definido por N
3. Equals(A,B) é verdadeiro se A for igual a B. Eles podem ser tipos diferentes; nesse caso, eles não serão iguais.
4. Modified(A)é verdadeiro se Afoi copiado para durante o último turno. Adeve ser um nome de variável, uma linha ou uma condição
5. Any(C1,C2,...) é verdadeiro se alguma das condições for verdadeira
6. None(C1,C2,...) é verdadeiro se nenhuma das condições for verdadeira
7. All(C1,C2,...) é verdadeiro se todas as condições forem verdadeiras
8. Not(C)é verdadeiro se C for falso. Cdeve ser uma condição.

As variáveis ​​podem estar em um dos seguintes formatos. Os 9 primeiros são numéricos e podem ser usados ​​sempre que N for usado nesta página.

1. A, B, C, D,E
2. Um número de 0 a 23
3. This retornará o número da linha em que está atualmente
4. Add(N1,N2,...) retornará a soma de todos os valores
5. Sub(N1,N2) retornará N1 menos N2
6. Mult(N1,N2,...) retornará o produto de todos os valores
7. Div(N1,N2) retornará N1 dividido por N2
8. Mod(N1,N2) retornará N1 mod N2
9. OVar(N) aceitará um nome de variável e retornará a variável do oponente
10. Line(N) retornará a enésima linha no seu código
11. Type(N) retornará o tipo de enésima linha no seu código (os tipos são os nomes das ações)
12. Cond(N) retornará a condição na linha Nésima
13. CondType(N) retornará o tipo de condição na enésima linha (os tipos são os nomes das condições)
14. OLine(N) retornará a enésima linha no código do seu oponente
15. OType(N) retornará o tipo de enésima linha no código do seu oponente
16. OCond(N) retornará a condição na enésima linha
17. OCondType(N) retornará o tipo de condição na enésima linha

Ae Bsão para seu uso pessoal, Cé usado para determinar qual linha executar no seu código e Dé usado como uma direção. Cada valor de Drefere-se a um par diferente de quadrado e direção. Eproduz um valor aleatório cada vez. De Eserá inicializado com um valor aleatório, caso contrário 0.

A direção usada será [North,East,South,West][D%4]. Seu oponente é o bot na praça imediata nessa direção.

Existem 4 ações disponíveis para você:

1. Movemoverá você 1 quadrado adiante na Ddireção th. Se houver um bot lá, você não se moverá.
2. Copy(A,B)copiará a variável Apara B. Bnão pode ser um valor numérico, exceto pelo nome de uma variável. Ae Bnão pode ser de tipos diferentes. Copiar uma linha não copia a condição.
3. Flagfaz nada. O bot com mais sinalizadores no seu código terá um ponto. O bot com mais pontos ganha.
4. If(C,L1,L2)executará a linha L1se Cfor verdadeira, caso contrário, executa L2. Cé uma condição L1e L2deve ser linhas.

A grande imagem

50 cópias de cada bot serão colocadas no mundo. Seu objetivo é colocar sua bandeira no maior número possível de bots. Para cada bot que possui mais do seu tipo de bandeira do que qualquer outro tipo de bandeira, você recebe um ponto.

Os bots serão colocados da seguinte maneira:

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

Serão 10 jogos disputados e a média de pontos será calculada em todos os jogos, determinando quem é o vencedor.

Notas laterais

Se várias condições se aplicarem, a que se seguir mais imediatamente Startserá executada

Os bots serão embalados de perto, mas você não começará outro vizinho. (Tecnicamente, ele terá o mesmo formato dos últimos CodeBots)

Como esse desafio não foi publicado na sandbox (para não dar vantagem a ninguém), reservo-me o direito de alterar pequenos detalhes por imparcialidade ou recursos adicionais. Além disso, se houver um bug no runner do CodeBots, eu o alterarei, mesmo que um bot dependa desse bug para obter sucesso. Estou tentando ser o mais justo possível.

Instruções recursivas Ifnão serão executadas

Se o seu bot for menor que 24 linhas, as linhas restantes serão preenchidas com Flag

Lembre-se de que ao copiar para si mesmo C, isso Cé incrementado no final do seu turno.

O interpretador do CodeBots pode ser encontrado aqui . Inclui um arquivo .jar para facilitar a execução. Basta adicionar seu bot à pasta de bots

Pontuações

1. 893,9 Borg
2. 1.3 LazyLioness
3. 0,9 Defensor
4. 0.5 Flagger
5. 0.4 CliqueBot
6. 0.4 Insidioso
7. 0.3 Atacante
8. 0.3 Gard
9. 0.3 SingleTarget
10. 0.2 FreezeBot
11. 0.2 Sentinel
12. 0.2 Driveby
13. 0.0 AntiInsidious
14. 0.0 MoveBot
15. 0.0 CliqueBorg
16. 0.0 Calculadora
17. 0.0 TestBot
18. 0.0 Imitador

ATUALIZAR

As linhas de código agora são giradas quando você visualiza o código do seu oponente. Isso significa que a linha 1 do seu oponente pode ser a linha 14 (ou qualquer que seja a linha). Um bot terá um deslocamento fixo que compensará suas linhas pela Xquantidade quando visto por um oponente . A Cvariável do oponente também será compensada pela mesma Xquantidade. Xnão mudará dentro do mesmo jogo, mas mudará de jogo para jogo.

Borg

Converte todos os outros bots em clones de si mesmo. Resistir é inútil.

Start:Copy(2,A)                               # Cloning will begin at line 2
All(Not(BotAt(D)),Not(Equals(2,A))):Copy(2,A) # Reset A if the opp left before we were done
Not(BotAt(D)):Move
All(Equals(Line(Sub(This,3)),OLine(0)),Equals(Line(Sub(This,2)),OLine(1)),Equals(Line(Sub(This,1)),OLine(2)),Equals(Line(This),OLine(3)),Equals(Line(Add(This,1)),OLine(4)),Equals(Line(Add(This,2)),OLine(5)),Equals(Line(Add(This,3)),OLine(6)),Equals(Line(Add(This,4)),OLine(7)),Equals(Line(Add(This,5)),OLine(8))):Copy(E,D) #  Check if cloning is complete
All(Equals(A,2),Not(Equals(OCond(1),Cond(Add(This,4))))):Copy(Cond(Add(This,4)),OCond(1)) # Copy freeze cond to OLine(1) before cloning starts
All(Equals(A,2),Not(Equals(OLine(1),Line(Add(This,3))))):Copy(Line(Add(This,3)),OLine(1)) # Copy freeze line
Not(Equals(Cond(Add(Sub(This,6),A)),OCond(A))):Copy(Cond(Add(Sub(This,6),A)),OCond(A))    # Copy Cond(A) to OCond(A)
Not(Equals(Line(Add(Sub(This,7),A)),OLine(A))):Copy(Line(Add(Sub(This,7),A)),OLine(A))    # Copy Line(A) to OLine(A)
Equals(A,A):Copy(Add(A,1),A) # Increment A. It will wrap around all 24 lines before the completion check matches

Edit: Pequena correção para redefinir A se o oponente se mover antes que eu termine com ele. Parece não afetar o placar, mas me faz sentir melhor.

Edição nº 2: adicionada uma verificação mais completa para garantir que o processo de clonagem seja concluído corretamente (linha 3)

Edit # 3: Update para lidar com os novos deslocamentos aleatórios. A dificuldade aqui era que os novos clones teriam seu código localizado em desvios aleatórios, o que significa que eles não sabem a localização de suas próprias linhas. Isso significa que todas as referências às minhas próprias linhas devem ser relativas (a This). Os números de linha do oponente ainda podem ser absolutos, pois são aleatórios de qualquer maneira.

Flagger

Tiro para a lua

Start:Flag

E o resto é preenchido automaticamente com a bandeira.

Calculadora

Esse bot não entende o objetivo desse desafio, então ele decidiu calcular alguns números para o inimigo.

Equals(Mod(OVar(E),5),0):Copy(Add(OVar(A),OVar(B)),OVar(D))
Equals(Mod(OVar(E),5),1):Copy(Sub(OVar(A),OVar(B)),OVar(D))
Equals(Mod(OVar(E),5),2):Copy(Mult(OVar(A),OVar(B)),OVar(D))
Equals(Mod(OVar(E),5),3):Copy(Div(OVar(A),OVar(B)),OVar(D))
Equals(Mod(OVar(E),5),4):Copy(Mod(OVar(A),OVar(B)),OVar(D))
Start:Move

CliqueBot

Flag
Start: Copy(11,B)
Not(Equals(Line(20),Line(21))): If(Equals(Line(21),Line(22)),Line(7),Line(8))
Not(Equals(Line(21),Line(22))): If(Equals(Line(20),Line(21)),Line(9),Line(10))
All(BotAt(D),Not(Equals(11,OVar(B)))): If(Equals(Line(20),OLine(OVar(C))),Line(10),Line(11))
Any(BotAt(D),Equals(E,B)): Copy(Add(D,1),D)
Equals(1,1): Move
Copy(Line(21),Line(20))
Copy(Line(20),Line(21))
Copy(Line(21),Line(22))
If(Equals(Line(20),OLine(Sub(OVar(C),1))),Line(5),Line(12))
Copy(Line(20),OLine(OVar(C)))
Copy(Line(20),OLine(E))

Reconhece os amigos pelo seu Bvalor, preenche as linhas de todos os outros com bandeiras. Também se esforça para preservar a integridade de uma de suas próprias bandeiras (essa parte é divertida, mas provavelmente não muito útil).

Edit: Sem surpresa, parece haver um bug aqui em algum lugar, a julgar pela pontuação.

Suspeito que as linhas sejam indexadas em 0 e meu código seja 1. Deveria realmente ter verificado isso antes. Adicionado uma bandeira no início para aumentar tudo.

Defensor

Start:Copy(0,A)
Copy(0,B)
Flag
Flag
All(Modified(Line(2)),Equals(A,0)):Copy(1,A)
Copy(Line(3),Line(2))
Copy(0,A)
Copy(10,C)
All(Modified(Line(3)),Equals(B,0)):Copy(1,B)
Copy(Line(2),Line(3))
Copy(0,B)
BotAt(D):Copy(Line(2),OLine(E))

MoveBot

Start:Move
Copy(E,D)
Copy(-1,C)

Atacante

Start:Move
BotAt(D):Copy(Line(Add(Mod(E,6),4)),OLine(E))
Any(BotAt(0),BotAt(1),BotAt(2),BotAt(3)):Move
None(BotAt(0),BotAt(1),BotAt(2),BotAt(3)):Copy(E,D)

Alvo único

Start:Move
All(BotAt(D),Not(Equals(OVar(D),D))): Copy(D,OVar(D))
BotAt(D):Copy(Line(E),OLine(E))
Equals(A,A):Move

Vai te caçar e te encher de bandeiras!

Insidioso

Start:Flag           # comments -->                                                                                 # why move when we can fit another flag here?
Equals(E,0):Copy(Add(D,Sub(Mult(2,Mod(E,2)),1)),D)                                                                  # 1/24 chance to turn left or right
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),1)),Cond(Add(This,4))))):Copy(Cond(Add(This,4)),OCond(Sub(OVar(C),1)))    # Copy the freeze condition
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),1)),Line(Add(This,4))))):Copy(Line(Add(This,4)),OLine(Sub(OVar(C),1)))    # Copy the flag-copying line
All(BotAt(D),Not(Equals(OLine(Add(OVar(C),0)),Line(Add(This,Add(4,Mod(E,14))))))):Copy(Line(Add(This,Add(4,Mod(E,14)))),OLine(Add(OVar(C),0))) # copy one of my flags to them
BotAt(D):Copy(Add(D,Sub(Mult(2,Mod(E,2)),1)),D)                                                                     # turn left or right if we've infected our target
Equals(A,A):Move                                                                                                    # move if all else fails, also infection freeze condition
Copy(Line(Add(This,1)),Line(Add(This,Mod(E,22))))                                                                   # infection line 1
Flag                                                                                                                # first of many flags

Idéia semelhante ao bot com o mesmo nome no concurso anterior. Mova até que eu acerte outro bot e congele-o em um loop substituindo seu próprio código com minhas bandeiras. Dessa vez, os bots infectados substituem linhas aleatórias em vez de sequenciais, tornando o processo de infecção um pouco menos eficaz, mas muito mais rápido.

Gard

Start: Move
BotAt(D):IF(Equals(Line(7),OLine(C)),Line(6),Line(5))
BotAt(Add(D,1)):Copy(Add(D,1),D)
BotAt(Add(D,2)):Copy(Add(D,2),D)
BotAt(Add(D,3)):Copy(Add(D,3),D)
Copy(Line(7),OLine(OVar(C)))
Copy(Cond(7),OCond(Sub(OVar(C),1)))

Ataca qualquer robô próximo a ele.

Congelar Bot

Start:Move
All(BotAt(D),Not(Equals(OCond(1),Cond(5)))):Copy(Cond(5),OCond(1))
All(BotAt(D),Not(Equals(OLine(1),Line(6)))):Copy(Line(6),OLine(1))
All(BotAt(D),Equals(Mod(OVar(A),24),0)):Copy(Add(D,1),D)
BotAt(D):Copy(Line(20),OLine(OVar(A)))
Equals(A,A):Move
Copy(Add(A,1),A)

Prende você em um loop Incriminando sua própria Avariável, depois o enche de bandeiras e passa para a próxima vítima.

Imitador

Start:Move
BotAt(D):If(OCond(0),OLine(0),Line(2))
If(OCond(1),OLine(1),Line(3))
If(OCond(2),OLine(2),Line(4))
If(OCond(3),OLine(3),Line(5))
If(OCond(4),OLine(4),Line(6))
If(OCond(5),OLine(5),OLine(OVar(C)))
Not(BotAt(D)):If(BotAt(Add(D,1)),Line(8),Line(0))
Copy(Add(D,1),D)

Prevê o que você faria, então faz isso.

Leoa preguiçosa

Originalmente apenas "Leoa", minha primeira submissão ao concurso ganhou o título de "preguiçoso", literalmente, sem fazer nada quando introduzido no simulador.

Sua letargia é de fato devido a um erro (ou possivelmente ao não entender o modelo do evento), em que as condições nas três primeiras linhas (uma simples verificação de paridade para garantir que as bandeiras não sejam sobrescritas) ocasionalmente, inexplicavelmente avaliam true, bloqueando leo em um loop de lemniscate . Várias outras condições (particularmente aquelas que dependem da BotAt()condição) também são avaliadas trueem momentos em que nenhum bot adjacente está presente. Finalmente, Movee Copydirectivas são claramente ignoradas quando percorrendo o simulador. Como minhas cadeias lógicas condicionais são um tanto épicas, há muito espaço para erros no meu código e no simulador. ;)

De qualquer forma, eu envio a Lazy Lioness como um caso de teste para diagnóstico de erros ou depuração do simulador, o que espero levar ao surgimento de leoa não tão preguiçosa que eu possa simular e refinar como meu primeiro envio de boa-fé aos Bots competição v2.

Não faz nada

All(Not(Equals(Line(18),Line(21))),Equals(Line(21),Line(22))):Copy(Line(21),Line(18))
All(Not(Equals(Line(21),Line(22))),Equals(Line(22),Line(18))):Copy(Line(22),Line(21))
All(Not(Equals(Line(22),Line(18))),Equals(Line(18),Line(21))):Copy(Line(18),Line(22))
All(Any(BotAt(Add(D,1)),BotAt(Add(D,2)),BotAt(Add(D,3))),Not(BotAt(D))):Move
All(Any(All(BotAt(D),BotAt(Add(D,2))),All(BotAt(D),BotAt(Add(D,1))),All(BotAt(Add(D,1)),BotAt(Add(D,2)))),Not(BotAt(Add(D,3)))):Copy(Add(D,3),D)
Any(All(Any(All(BotAt(D),BotAt(Add(D,2))),All(BotAt(D),BotAt(Add(D,3))),All(BotAt(Add(D,2)),BotAt(Add(D,3)))),Not(BotAt(Add(D,1)))),All(BotAt(Add(D,1)),BotAt(D),Any(Equals(OCond(2),Cond(20)),Equals(OLine(2),Line(19))))):Copy(Add(D,1),D)
All(BotAt(Add(D,3)),BotAt(D),Any(Equals(OCond(2),Cond(20)),Equals(OLine(2),Line(19)))):Copy(Add(D,3),D)
All(BotAt(D),Not(Equals(OCond(2),Cond(20))),Not(Equals(OLine(2),Line(19)))):Copy(Cond(20),OCond(2))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(3),Line(18)))):Copy(Line(18),OLine(3))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(4),Line(21)))):Copy(Line(21),OLine(4))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OCond(0),Cond(22)))):Copy(Cond(22),OCond(0))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(0),Line(17)))):Copy(Line(17),OLine(0))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OCond(1),Cond(21)))):Copy(Cond(21),OCond(1))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(1),Line(20)))):Copy(Line(20),OLine(1))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(2),Line(19)))):Copy(Line(19),OLine(2))
All(BotAt(D),Not(Equals(OCond(2),Cond(20))),Equals(OLine(2),Line(19))):Copy(Add(D,A),D)
Equals(E,1):Copy(Add(A,2),A)
Any(Equals(E,4),Equals(E,8)):Copy(Add(D,E,A),D)
Not(Equals(A,A)):Flag
Not(Equals(A,A)):Copy(Line(3),OLine(E))
Equals(A,A):Move
Any(Equals(E,4),Equals(E,5),Equals(E,6),Equals(E,7),Equals(E,8),Equals(E,9)):Flag
Any(Equals(E,10),Equals(E,11),Equals(E,12),Equals(E,13)):Flag
Start:Copy(1,A)

sentinela

melhoria Gard. Atinge bots próximos com bandeiras nas 8 primeiras linhas. (ou seja, todos os mais usados)

flag
flag
Start:Copy(11,B)
All(BotAt(D),Not(Equals(OLine(Mod(E,8)),Line(0))),Not(BotAt(Add(D,1,Mod(E,3))))):If(Equals(OVar(D),Add(D,2)),Line(7),Line(8))
BotAt(Add(D,1)):Copy(Add(D,1),D)
BotAt(Add(D,2)):Copy(Add(D,2),D)
BotAt(Add(D,3)):Copy(Add(D,3),D)
copy(D,OVar(D))
copy(Line(Mod(E,2)),OLine(Mod(E,8)))
Not(Equals(Line(0),Line(1))):copy(Line(Add(9,Mod(E,16))),Line(Mod(E,2)))

CliqueBorg

Flag
BotAt(D): Copy(Line(Sub(This,1)),OLine(E))
Equals(1,1): Copy(Line(Sub(This,2)),Line(Add(This,Mod(E,21))))
Start: Move
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),1)),Line(3)))):Copy(Line(3),OLine(Sub(OVar(C),1)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),1)),Cond(3)))):Copy(Cond(3),OCond(Sub(OVar(C),1)))
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),2)),Line(2)))):Copy(Line(2),OLine(Sub(OVar(C),2)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),2)),Cond(2)))):Copy(Cond(2),OCond(Sub(OVar(C),2)))
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),3)),Line(1)))):Copy(Line(1),OLine(Sub(OVar(C),3)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),3)),Cond(4)))):Copy(Cond(4),OCond(Sub(OVar(C),3)))

Tentando combinar as tecnologias CliqueBot e Borg para criar um bot que reconhece cópias de si mesmo, apesar do deslocamento da linha. Ele também inicia seu processo de cópia na última linha de código executada no bot oposto, em vez da linha 0, que é mais provável que o congele no lugar, mas também que provavelmente resultará em uma cópia corrompida (na verdade, eu não sou Certifique-se de que isso funcione, não testei e é bastante complexo).

Dirigir por

Uma última tentativa antes do prazo.

Flag
Flag
BotAt(D):Copy(Line(Sub(This,1)),OLine(E))
Equals(1,1):Copy(Line(Sub(This,2)),Line(Add(This,Mod(E,21))))
Start:Move
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),1)),Line(3)))):Copy(Line(3),OLine(Sub(OVar(C),1)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),1)),Cond(3)))):Copy(Cond(3),OCond(Sub(OVar(C),1)))
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),2)),Line(2)))):Copy(Line(2),OLine(Sub(OVar(C),2)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),2)),Cond(2)))):Copy(Cond(2),OCond(Sub(OVar(C),2)))
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),3)),Line(1)))):Copy(Line(1),OLine(Sub(OVar(C),3)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),3)),Cond(4)))):Copy(Cond(4),OCond(Sub(OVar(C),3)))
BotAt(D):Copy(Add(D,1),D)
Equals(1,1):Move