Mario cairá no satélite encolhendo? (Diagrama adicionado)

23

Super Mario Galaxy apresenta dois planetas em forma de rhombicuboctahedron * revestidos de plataformas que encolhem quando Mario atravessa. Se Mario cair em um buraco triangular ou em um espaço deixado por um ladrilho que ele tocou anteriormente, ele será consumido pelo buraco negro no núcleo. (Assista: Galaxy apressado , Galaxy Slide do mar )

Imagem: MarioWiki.com

Imagem: MarioWiki.com

(Você pode pensar no planeta como um cubo 2x2x2 cujas faces foram separadas e conectadas umas às outras por "pontes" 2x3.)

Infelizmente, como meu controlador está muito quebrado, Mario não pode pular e está limitado às quatro direções principais. Além disso, Mario se move muito devagar e não pode recuar nem um passo sem primeiro ter a plataforma atrás dele desaparecendo.

Vamos supor que a câmera esteja sempre acima da cabeça de Mario e ele começa no canto inferior direito de um rosto 2x2:

      ■ ■
      ■ ■
      ■ ■
■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ M ■ ■ ■
      ■ ■
      ■ ■
      ■ ■

Seu programa seguirá uma lista ou uma sequência de instruções U D L R(para cima, baixo, esquerda, direita), representando a caminhada de Mario ao redor do planeta até uma série de etapas. O programa pode gerar uma de duas saídas distintas: uma representando que Mario ainda está vivo e andando, e a outra representando que, em algum momento de sua caminhada, Mario caiu no Satélite Encolhendo.

RR:   ■ ■                 RRD:  ■ ■                 RRL:  ■ ■      
      ■ ■                       ■ ■                       ■ ■      
      ■ ■                       ■ ■                       ■ ■      
■ ■ ■ ■ ■ ■ ■ ■           ■ ■ ■ ■ ■ ■ ■ ■           ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ □ □ M ■           ■ ■ ■ ■ □ □ □ ■           ■ ■ ■ ■ □ M □ ■
      ■ ■    \                  ■ ■   M                   ■ ■  \
      ■ ■     Let's-a go!       ■ ■    \                  ■ ■   W-aaaaaaaaaahh!
      ■ ■                       ■ ■     W-aaaaaaaaaahh!   ■ ■

Obviamente, ao contrário dos diagramas acima, você terá que levar em conta o 3D. Aqui está um diagrama que pode ajudá-lo a visualizar melhor o cenário:

                Top 2x2 face
   <- clockwise           anticlockwise ->
   -   ■    -    ■    -    ■    -    ■   -
     /   \     /   \     /   \     /   \  
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■    Left and right
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ M ■ ■ ■ ■ ■ ■ ■ ■ ■    edges wrap around.
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
     \   /     \   /     \   /     \   /  
   -   ■    -    ■    -    ■    -    ■   -
   <- anticlockwise           clockwise ->
               Bottom 2x2 face

Portanto, de acordo com este diagrama, UUUUURRRRpode ser assim:

   -   ■    -    ■    -    □    -    ■   -
     /   \     /   \     /   \     /   \  
   ■       ■ ■       ■ □       □ ■       ■
   ■       ■ ■       ■ □       □ ■       ■
   ■       ■ ■       ■ □       □ ■       ■
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ ■ ■ ■ M ■ ■ ■ ■ ■
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
     \   /     \   /     \   /     \   /  
   -   ■    -    ■    -    ■    -    ■   -

E UUUUUUUUULURRRRRRpode ficar assim:

   -   ■    -    ■    -    □    -    □   -
     /   \     /   \     /   \     /   \  
   ■       ■ ■       ■ □       ■ ■       □
   ■       ■ ■       ■ □       ■ ■       □
-> □       ■ ■       ■ □       ■ ■       □ ->
<- □ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ ■ ■ ■ M □ □ □ □ □ <-
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
     \   /     \   /     \   /     \   /  
   -   ■    -    ■    -    ■    -    ■   -

Que o programa mais curto em bytes seja w-aaaaaaaaaahh!

Casos de teste

Saída 1: Ainda Vivo

DDDDDLUUUUU - Mario atravessa uma ponte e volta.

RRRRDDDDLLL - Mario anda em um triângulo.

LLLLLLUUUUUURRRRR - Mario entra em um triângulo maior.

ULLDRDDDRU - Mario se coloca em perigo.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR - Mario segue um caminho não convencional ... e se arrisca.

Mario atravessa cada peça exatamente uma vez. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

Saída 2: W-aaaaaaaaaahh!

LLR - Mario tenta recuar um passo e cai.

UULDR - Mario tenta cruzar uma peça duas vezes e pisa no ar.

RRDDDDD - Mario sai de uma ponte no primeiro D (ignora os passos seguintes).

RRRRDDDDLLLL - Mario caminha em um triângulo e cai através da peça inicial.

LLLLLLUUUUUURRRRRR - Mario caminha em um triângulo maior e cai através da peça inicial.

UUUUUUUUUUUUUUUUUUUU - Mario anda por todo o planeta e cai no ladrilho inicial.

RURDRURDRDLDRDLDLDLULDLLUU - Mario segue uma rota não convencional e fica desorientado.

Mario, percebendo o perigo em que está, não tem escolha.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

Por fim, copie qualquer caso de teste de "Mario cruza todos os blocos exatamente uma vez" e altere ou adicione uma etapa aleatoriamente. Mario deve cair. (Se você adicionar um passo até o fim, Mario cai para pegar a Power Star!)

* Cubo cantelado seria um termo mais correto, já que algumas faces não são quadradas, mas é preciso admitir - o "rhombicuboctahedron" flui melhor.

darrylyeo
fonte
3
Os pontos de bónus para resolver isso em Cubix ou cúbico
Stephen
Isso traz de volta tantas memórias de jogar Mario Galaxy - facilmente um dos meus jogos favoritos de todos os tempos.
precisa saber é o seguinte
7
@StepHen Or MarioLANG: P
ETHproductions
@ Stephen mesmo que seja um octogono, hexagonia sti ... Sabe o que, não importa, quem faria isso em hexAgony.
Magic Octopus Urn
No quarto do último caso de teste, Mario não morre a menos que você adicione um extra R. Eu trabalhei isso no papel para garantir que meu código esteja correto.
Level River St

Respostas:

6

Ruby, golfe, 244 230 bytes

Parece funcionar bem, testará um pouco mais.

->s{a=[8**8/5]*8
v=[-1,x=d=0,1,0]
y=m=4
s.chars{|c|a[y]&=~(1<<x) 
y+=v[e="URDL".index(c)+d&3]
x+=v[e-1]
r= ~0**q=x/4
i=q+x&1
j=q+y&1
y%9>7&&(y=4-i;x+=4-j*11-x%2;d+=r)
x&2>0&&-y/2==-2&&(y=i*7;x+=6-x%2*9+j;d-=r)
m*=1&a[y]>>x%=24}
m}

Ruby, primeira versão de trabalho, 260 bytes

Experimente online

Função Lambda usando um argumento de string. Retorna 4 para vivo, 0 para morto.

->s{a=[0x333333]*8
v=[0,-1,0,1]
x=d=0
y=m=4
s.chars{|c|a[y]&=~(1<<x) 
e="URDL".index(c)+d
x+=v[e%4]
y+=v[-~e%4]
p=x&-2
q=x/4%2
y%9>7&&(d-=q*2-1;y,x=4-(q+x)%2,(p+4-(q+y)%2*11)%24)
x&2>0&&-y/2==-2&&(y,x=(q+x)%2*7,(p+6-x%2*8+(q+y)%2)%24;d+=q*2-1)
m*=a[y]>>x&1}
m}

Explicação

O tabuleiro é desdobrado em 6 tiras de tamanho 2x8, representadas pelos caracteres /\e Oabaixo. Elas são mapeadas em um mapa 2D 24 * 8, onde x = (número da faixa) * 4 + (posição horizontal na faixa) e y = posição vertical na faixa.

       Map        4         2         0          Initial state of array a
                 /         /         /   
                / /       / /       / /          1100110011001100110011
               / /       / /       / /           1100110011001100110011 
              O /       O /       O /            1100110011001100110011
             O O       O O       O O             1100110011001100110011
      \     / O \     / O \     / X              110011001100110011001X
     \ \   / / \ \   / / \ \   / /               1100110011001100110011
      \ \ / /   \ \ / /   \ \ / /                1100110011001100110011
       \ O /     \ O /     \ O /                 1100110011001100110011
        O O       O O       O O 
         O \       O \       O \                 X=Mario's start point 
          \ \       \ \       \ \  
           \ \       \ \       \ \    
            \         \         \
             5         3         1

Eles são armazenados em uma matriz de 8 números binários; portanto, x aumenta para a esquerda e y aumenta para baixo.

A matriz é inicializada com 8 cópias do número 0x33333333. Isso forma os quadrados em que Mario pode pisar. Quando Mario se move ao redor do quadrado em que ele está, é definido como zero, e o quadrado para o qual ele está se mudando é testado - ele vive com um 1 e morre se contiver um 0.

Se Mario sai da parte superior ou inferior da faixa em que está, ele se move para outra faixa. Se ele sair do lado da faixa em que está, se estiver em um quadrado com y = 3 ou y = 4, ele se moverá para outra faixa. Se y não é 3 ou 4, ele não se move para outra faixa e acaba em um quadrado que tinha 0 desde o início do jogo, então ele morre.

Como a câmera está sempre acima da cabeça de Mario, sempre que ele muda de faixa, a referência para as direções deve ser girada em 90 graus.

Ungolfed in program program

f=->s{                             #Move sequence is taken as string argument s.
  a=[0x333333]*8                   #Setup board as an array of 8 copies of 1100110011001100110011.
  v=[0,-1,0,1]                     #Displacements for moving.
  x=d=0                            #Mario starts at 0,4.
  y=m=4                            #d=offset for directions. m=4 when Mario is alive (value chosen for golfing reasons) 0 when dead.

  s.chars{|c|                      #For each character c in s
    a[y]&=~(1<<x)                  #Set the square where Mario is to 0.

    e="URDL".index(c)+d            #Decode the letter and add the offset 
    x+=v[e%4]                      #x movement direction is v[e%4]   
    y+=v[-~e%4]                    #y movement direction is v[(e+1)%4]
    p=x&-2                         #p is a copy of x with the last bit set to zero (righthand edge of strip).
    q=x/4%2                        #q is 0 for an even number strip, 1 for an odd number strip.
    y%9>7&&(                       #If y out of bounds (8 or -1)
      d-=q*2-1;                    #Adjust d so directions will be interpreted correctly on the next move.
      y,x=
        4-(q+x)%2,                 #y becomes 3 or 4 depending on the values of q and x.
        (p+4-(q+y)%2*11)%24        #If q+y is even, move 1 strip left. if even, move 2 strips right. Take x%24.  
    )
    x&2>0&&-y/2==-2&&(             #If x&2>0 Mario has walked sideways off a strip. If y is 3 or 4, move him to a different strip.
      y,x=                       
        (q+x)%2*7,                 #y becomes 0 or 7, depending on the values of q and x.
        (p+6-x%2*8+(q+y)%2)%24;    #If x%2 is even, move 2 strips left. If odd, move 1 strip right*. Pick the left or right column of the strip depending on (q+y)%2. Take x%24 
        d+=q*2-1                   #Adjust d so directions will be interpreted correctly on the next move.
    )

    m*=a[y]>>x&1                   #Multiply m by the value (0 or 1) of the current square. Mario is either alive (4) or dead (0).  
    #puts x,y,m,a.map{|i|"%022b"%i}#Uncomment this line for diagnostics.
  }
m}                                 #Return value of m.  


#Still alive, return value 4
puts f["DDDDDLUUUUU"] # Mario walks across a bridge and back.
puts f["RRRRDDDDLLL"] # Mario walks in a triangle.
puts f["LLLLLLUUUUUURRRRR"] # Mario walks in a bigger triangle.
puts f["ULLDRDDDRU"] # Mario puts himself in peril.
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRR"] # Mario takes an unconventional route... and puts himself in peril.
puts f["DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD"] 
puts f["DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU"]

#Dead, return value 0

puts f["LLR"] #  Mario attempts to retrace a step and falls off.
puts f["UULDR"] #  Mario attempts to cross a tile twice and steps into air.
puts f["RRDDDDD"] #  Mario walks off a bridge at the first D (ignore any following steps).
puts f["RRRRDDDDLLLL"] #  Mario walks in a triangle and falls through the starting tile.
puts f["LLLLLLUUUUUURRRRRR"] #  Mario walks in a bigger triangle and falls through the starting tile.
puts f["UUUUUUUUUUUUUUUUUUUU"] #  Mario walks all the way around the planet and falls through the starting tile.
puts f["RURDRURDRDLDRDLDLDLULDLLUU"] # 

puts f["ULLDRDDDRUUU"] 
puts f["ULLDRDDDRUUL"] 
puts f["ULLDRDDDRUUR"] 
puts f["ULLDRDDDRUUD"] 
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR"] #text case in q is wrong. one more R added to make the kill.
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRU"] 
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRL"] 
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRD"]
Level River St
fonte
Bem feito! Eu realmente gosto do mapeamento "strip" e da maneira como você explica o ângulo da câmera.
darrylyeo