fundo

Aqui está um desafio relacionado ao Halloween.

Como você deve ter visto no meu último desafio , gosto bastante do que chamo de animações de arte ascii, que não é apenas desenhar um padrão, mas sim um padrão que progride. Essa idéia veio à minha mente depois que me pediram, há alguns anos, para animar uma apresentação (bastante chata), fazendo morcegos ascii aleatórios voarem pela tela no Halloween. Escusado será dizer que eu estava devidamente obrigado (eu estava sendo pago por isso), mas isso me fez pensar que há mais na vida do que morcegos aleatórios. Inspirado por isso, gostaria de propor este desafio.

Desafio

Faça um morcego voar ao redor da lua.

Aqui está um morcego:

^o^

Aqui está a lua:

     mmm         
   mmmmmmm       
  mmmmmmmmm      
   mmmmmmm       
     mmm     

Você deve mostrar todas as etapas do voo dos morcegos (consulte a saída).

Entrada

Nenhum

Saída

      ^o^         
      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm^o^      
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm^o^    
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm^o^   
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm^o^    
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm^o^      


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         
      ^o^         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
   ^o^mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
 ^o^mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
^o^mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
 ^o^mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


   ^o^mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      ^o^         
      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm   

Regras

• Nenhuma leitura de arquivos ou sites externos
• Você pode enviar um programa completo ou uma função
• Espaços extras e / ou novas linhas são ótimos para mim
• Falhas padrão banidas como de costume
• O morcego deve terminar de volta ao topo da lua
• Sinta-se à vontade para limpar a tela entre os quadros, se desejar, porém isso não é um requisito. A saída mostrada acima é boa
• Como se trata de código de golfe, o vencedor será a resposta com a menor contagem de bytes, embora qualquer resposta seja bem-vinda

Amostra

Implementação de referência em Python 2 totalmente não-destruído (620 bytes, mas apenas para provar que isso pode ser feito. Pode jogar mais tarde).

b='^o^'
m=['                     ',
'         mmm         ',
'       mmmmmmm       ',
'      mmmmmmmmm      ',
'       mmmmmmm       ',
'         mmm         ',
'                     ']
p=[(9,12),(12,15),(14,17),(15,18),(14,17),(12,15),(9,12),(6,9),(4,7),(3,6),(4,7),(6,9),(9,12)]
d=0
for z in range(7):
    x=map(str,m[z])
    c="".join(x[:p[z][0]]) + b + "".join(x[p[z][1]:])+"\n"
    print "\n".join(m[:z]) + "\n" + c+"\n".join(m[z+1:])
for z in range(6)[::-1]:
    x=map(str,m[z])
    c="".join(x[:p[z+6][0]]) + b + "".join(x[p[z+6][1]:])+"\n"
    print "\n".join(m[:z]) + "\n" + c+"\n".join(m[z+1:])

Resultado

Embora @ Jonathan, obviamente, vença em contagem de bytes com Jelly, vou marcar a resposta Brainfuck de @Oyarsa como a resposta aceita apenas porque acho que qualquer pessoa que possa realmente fazer algo assim em um idioma tão louco merece +15 representantes, independentemente de quantos bytes são necessários. Isso não é porque eu tenha algum problema com os idiomas do golfe. Veja minha resposta a uma pergunta sobre isso no meta, se você tiver alguma dúvida. Muito obrigado e respeito a todos que contribuíram em qualquer idioma.

Brainfuck, 690 bytes

Esta é minha primeira vez jogando golfe, então tenho certeza de que ainda há muito espaço para melhorias

-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+[<]>[[<+>>-[>]+[[<]>+[>]<+[<]>>>-]<<[->>+<<]>-]>-[->>>>+<<<<]>++]>>>[[-]<]>>>>[>]>>+>+++++++<<<<[<]+<+<<+[[<]++++[>++++<-]>[<+[>]>[-<+>]<[<]>>-]>[>]++++++++++[>]>>>-[<]<<[<]<]<[<]>->-<<<[-]++++++<+<+++[>++++++<-]+<++++[>++++++++<-]---<-[>+<-----]++<----[>+<----]--<-[>+<---]<-[>++<-----]++++<-[>+<---]++<-[>+<-------]---<----[>+<----]<--[>+<++++++]<+++++[>+++++<-]++++++>[[[>]>[>]>>[-<<+>>]<<[<]<[<]>-]>[>]>[>]+++++++[>+++++++++<-]>-[->+>+>+<<<]++++[>>++++<<-]>>+<<<<[<]>[.>]>>[.>]<[<]>[-]>[-]>[-]<+[--<---[->]<]<[->+>+>+<<<]<<[[->>+<<]<]<]

Experimente online

Ungolfed alguns para legibilidade:

-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+
Sets counters for creation of the m's and spaces
[<]>[[<+>>-[>]+[[<]>+[>]<+[<]>>>-]<<[->>+<<]>-]>-[->>>>+<<<<]>++]
Adds the first counter plus two of the character at the second counter to the end of the
current set of cells removes the first two counters on the list then repeats until
it encounters a 254
>>>[[-]<]>>>>[>]>>+>+++++++<<<<[<]
Removes some excess cells then adds a 7 after the end of the set of cells
+<+<<+[[<]++++[>++++<-]>[<+[>]>[-<+>]<[<]>>-]>[>]++++++++++[>]>>>-[<]<<[<]<]
Adds a newline every 16 characters until 7 newlines are added
<[<]>->-<<<[-]++++++<+<+++[>++++++<-]+<++++[>++++++++<-]---<-[>+<-----]++<----[>+<----]--<-[>+<---]<-[>++<-----]++++<-[>+<---]++<-[>+<-------]---<----[>+<----]<--[>+<++++++]<+++++[>+++++<-]++++++
Removes some excess cells then sets indices for the locations of bats
>[[[>]>[>]>>[-<<+>>]<<[<]<[<]>-]>[>]>[>]+++++++[>+++++++++<-]>-[->+>+>+<<<]++++[>>++++<<-]>>+<<<<[<]>[.>]>>[.>]<[<]>[-]>[-]>[-]<+[--<---[->]<]<[->+>+>+<<<]<<[[->>+<<]<]<]
Loops through the indices replacing the spaces at each index with a bat then printing 
the set of cells then changing the bat back to spaces

Eu queria usar o fato de que, adicionando uma nova linha ao início, cada estágio pode ser lido nas duas direções para obter dois estágios diferentes, mas não consegui encontrar uma boa maneira de fazer isso sem gerar os seis estágios e meio completos de uma vez só.

05AB1E , 69 62 60 bytes

Economizou 2 bytes graças a Adnan .

3ð×…^o^)U13FNV0379730vð5y>;ï-y_+×N(Y-12%_Xè'my×NY-12%_y&XèJ,

Experimente online!

Explicação

3ð×…^o^)Uarmazena a lista [" ","^o^"]em X para uso posterior.

13FNVfaz um loop nos 13 estágios [0 .. 12] e armazena o índice de iteração atual em Y .

0379730vcircula as linhas de cada estágio,
onde N é o índice da linha e y é o número atual de m .

Começamos adicionando floor(5/(y+1))-(y==0)espaços a cada linha com ð5y>;ï-y_+×.

Em seguida, determinamos se deve haver um bastão ou 3 espaços antes dos m's .
Se (-N-Y)%12 == 0for verdade, adicionamos um morcego, mais 3 espaços.
Esta expressão ( N(Y-12%_Xè) colocará morcegos em etapas 0,6-12.

Então colocamos y 's com 'my×.

Agora, determinamos se deve haver um bastão ou três espaços após os m's .
O código NY-12%_y&Xècolocará um bastão, se ((N-Y)%12 == 0) and y!=0for verdadeiro, mais 3 espaços.
Isso colocará os morcegos nos palcos 1-5.

Finalmente, junte-se a linha inteira em uma string e imprimir com uma nova linha: J,.

JavaScript (ES6), 109 144 140 138 bytes

f=(k=13,b=y=>(y-k)%12?'   ':'^o^')=>k--?[0,3,7,9,7,3,0].map((n,y)=>' '.repeat(5-n/2+!n)+b(y)+'m'.repeat(n)+b(n?-y:.1)).join`
`+`
`+f(k):''

console.log(f());

Versão animada

f=(k,b=y=>(y-k)%12?'   ':'^o^')=>[0,3,7,9,7,3,0].map((n,y)=>' '.repeat(5-n/2+!n)+b(-y)+'m'.repeat(n)+b(n?y:.1)).join`
`

var k =0;
setInterval(function() { o.innerHTML = f(k++) }, 150);

<pre id=o></pre>

HTML + JS, 153 149 bytes

n=setInterval(_=>o.innerText=`zzd
zc3e
 b7f
a9g
 l7h
zk3i
zzj`.replace(/\S/g,c=>parseInt(c,36)-n%12-10?`m`.repeat(c)||`   `:`^o^`,n++),1e3)

<pre id=o>

Editar: salvou um monte de bytes graças a @RickHitchcock. A versão chata que apenas retorna as 13 seqüências multilinhas em uma matriz é 132 131 bytes:

_=>[...Array(13)].map((_,n)=>`zza
zl3b
 k7c
j9d
 i7e
zh3f
zzg`.replace(/\S/g,c=>parseInt(c,36)-n%12-10?`m`.repeat(c)||`   `:`^o^`))

Geléia , 76 69 58 bytes

⁾ mṁ11ż“椿¬®µ‘ŒḄ¤Œṙs⁴Y
_4¢ḣ;“^o^”;¢ṫ⁸¤
“½œ0CSbp\I7'ð½‘Ç€Y

TryItOnline

Quão?

⁾ mṁ11ż“椿¬®µ‘ŒḄ¤Œṙs⁴Y - Link 1, make a moon (niladic)
⁾ m                     - literal " m"
   ṁ                    - reshape like
    11                  - 11 (interpreted as range(11)) -> " m m m m m "
                 ¤      - nilad followed by links as a nilad
       “椿¬®µ‘         - code page indexes [22,3,11,7,8,9]
               ŒḄ       - bounce -> [22,3,11,7,8,9,8,7,11,3,22]
      ż                 - zip -> [[22,' '],[3,'m'],[11,' '],...]
                  Œṙ    - run length decode -> "                      mmm           mmmmmmm        mmmmmmmmm        mmmmmmm           mmm                      "
                    s   - split into chunks of length
                     ⁴  - l6
                      Y - join with line feeds

_4¢ḣ;“^o^”;¢ṫ⁸¤ - Link 2, a moon with a bat placed: endIndex
_4              - subtract 4 (startIndex)
  ¢              - call last link (1) as a nilad
   ḣ            - ḣead to startIndex
    ;           - concatenate
     “^o^”      - literal "^o^"
          ;     - concatenate
              ¤ - nilad followed by links as a nilad
           ¢    - call last link (1) as a nilad
            ṫ⁸  - tail from endIndex

“½œ0CSbp\I7'ð½‘Ç€Y - Main link (niladic)
“½œ0CSbp\I7'𽑠   - code page indexes [10,30,48,67,83,98,112,92,73,55,39,24,10]
                   -    indices to the right of each bat in a constructed moon
               ǀ  - call last link (2) as a monad for each
                 Y - join on line feeds

Python 2, 146 144 138 bytes

-2 bytes graças a @Willem (use a variável c vez de repetir a map)

m='\n'.join(int(a)*' '+int(b)*'m'+3*' 'for a,b in zip('6643466','0379730'))
for b in" -;L[hrbQ@2' ":c=ord(b)-23;print(m[:c-3]+'^o^'+m[c:])

repl.it

'6643466' é o número de espaços antes da lua (com 6 na primeira e na última linhas vazias, já que o morcego vai para lá).

'0379730' é o número de 'm' s na lua em cada linha.

O zipdescompacta esses personagens em ae be faz a lua no céu,m , com 3 espaços à direita em cada linha.

A última linha percorre as posições do morcego dentro da lua e é efetivamente:

for c in(9,22,36,53,68,81,91,75,58,41,27,16,9):print(m[:c-3]+'^o^'+m[c:])

mas a tupla de posições é codificada como ordinais de caracteres imprimíveis, com 23 adicionados (já que 9 não é imprimível). Isso sai como " -;L[hrbQ@2' "e c=ord(b)-23é usado para extrair os valores.

Autovim , 85 81 bytes

Nenhuma animação, provavelmente ainda jogável ... Ainda assim, nada mal para o garoto novo do quarteirão! (autovim)

ñ9am␛ÿP2xÿP4xyjGpđp2o
%ce 15
®q=8j$p
®z=6␍"_d3hP
ñğyG12PğÿPC^o^␛v^y6@q==o␛6@z==O

Para executá-lo:

autovim run ascii-bat.autovim -ni

Explicação

Em resumo, desenhamos a lua, copiamos e colamos 12 vezes e usamos duas macros: uma para acrescentar o morcego nas primeiras 7 luas e a outra para acrescentar as últimas 6.

" Draw the moon
ñ                                 " Normal mode
 9am␛                            " Write 9 `m`
      ÿP                          " Duplicate the line
        2x                        " Delete two characters
          ÿP                      " Duplicate the line
            4x                    " Delete 4 characters
              yj                  " Yank two lines
                Gp                " Paste at the end of the file
                  đp              " inverts the current line with the previous
                    2o            " Add two line breaks

%ce 15                            " Center our moon

" Macros
®q=8j$p                           " Macro `q` jumps 8 lines, and pastes
                                  "   at the end
®z=6␍"_d3hP                      " Macro `z` jumps 6 lines and replaces
                                  "   the previous 3 characters by the default

" Draw all 12 moons and add the bats
                                  "   register's content
ñ                                 " Run in normal mode
 ğyG                              " Copy the moon we just drew
    12P                           " Duplicate the moon 12 times
       ğÿP                        " Duplicate the top line (gets 3 centered `m`)
          C^o^␛                  " Change the mmm by a bat
                v^y               " Copy the bat we just drew
                   6@q            " Add the first 6 bats
                      ==          " Center the bat
                        o␛       " Add a line under the bat
                           6@z    " Add the 6 last bats
                              ==  " Align the last bat in the center
                                O " Add a line over the last moon

PHP, 167 bytes

Eu fiz um pequeno programa em PHP:

<?php foreach([0,3,7,9,7,3,0]as$l)$b.=str_pad(str_repeat('=',$l),15," ",2)."\n";foreach([6,25,43,60,75,89,102,83,65,48,33,19,6]as$x)echo substr_replace($b,'^o^',$x,3);

Aqui está uma versão mais detalhada:

// width of the moon
$moonsizes = [0,3,7,9,7,3,0];
// position where to place the bat
$positions = [6,25,43,60,75,89,102,83,65,48,33,19,6];
// prepare base moon painting
foreach($moonsizes as $size){
    $basepainting .= str_pad(str_repeat('=',$size),15," ",STR_PAD_BOTH)."\n";
}
// loop frames and place bat
foreach($positions as $position) {
    echo substr_replace($basepainting,'^o^',$position,3);
}

Este é o meu primeiro codegolf, se você tiver alguma sugestão, fico feliz em ouvir :)

Python 2, 112 bytes

b=['   ','^o^']
for k in range(91):r=k%7;print(b[k/7+r==12]*(r%6>0)+(r*(6-r)*8/5-5)*'m'+b[k/7%12==r]).center(15)

Imprima a imagem. Cada linha tem três partes

• Um morcego em potencial à esquerda
• Algum número de m 's para a lua
• Um morcego em potencial à direita

Essas peças são concatenadas e centralizadas em uma caixa de tamanho 15 para espaçamento. Para evitar que os morcegos mudem de centro, um morcego ausente tem três espaços, o mesmo comprimento. Para morcegos em cima ou abaixo da lua, o slot da barra esquerda é omitido e o slot direito é ocupado.

Existem 91 linhas: uma imagem de 7 linhas para cada uma das 13 fotos. Estes são contados via divmod: como kconta de 0até 91, (k/7, k%7)vai

(0, 0)
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(0, 5)
(0, 6)
(1, 0)
(1, 1)
 ....
(12, 5)
(12, 6)

Tomando o primeiro valor k/7para ser a imagem e o segundo valorr=k%7 como o número da linha na figura, isso conta primeiro pela figura e depois pelo número da linha em cada figura, ambos indexados em 0.

O número de m's na lua muda com o número da linha r=k%7como[0,3,7,9,7,3,0] . Em vez de indexar isso, uma fórmula era mais curta. Um grau conveniente de liberdade é que os valores 0podem ter qualquer valor negativo, pois isso ainda fornece a cadeia vazia quando multiplicada porm . Brincar com uma parábola e dividir o chão deu uma fórmular*(6-r)*8/5-5 .

Agora, analisamos a escolha de desenhar um morcego ou um espaço vazio em ambos os lados. A matrizb=[' ','^o^'] contém as opções.

O taco na linha 0 aparece na figura 0 (na parte superior), na linha 1 na figura 1 (à direita) e na linha 6 na figura 6 (na parte superior). Portanto, é fácil verificar se aparece como o número da linha e da imagem como sendo igual,k/7==r ,. Mas também precisamos da figura 12 para se parecer com a figura 0, então pegamos o número da figura módulo 12 primeiro.

À esquerda é semelhante. O morcego aparece à esquerda em linhas r=5,4,3,2,1nas imagens 7,8,9,10,11. Portanto, verificamos se o número da linha e da imagem é igual a 12. Também asseguramos não desenhar nada em vez de três espaços nas linhas 0e 6- o slot do bastão certo irá desenhar o bastão e não devemos estragar sua centralização.

C #, 615 582 337 bytes

Esta é a minha primeira tentativa (ainda muito legível) de uma delas, por isso ficarei feliz em receber sugestões para cortar algumas centenas de bytes! No topo da minha lista, no momento, há uma maneira mais curta de criar a matriz da lua.

void M(){string[]m={"","      mmm","    mmmmmmm","   mmmmmmmmm","    mmmmmmm","      mmm",""};var b="^o^";for(int x=0;x<13;x++){var a=(string[])m.Clone();int n=x>6?12-x:x;int[] j={0,1,3,6};a[n]=!a[n].Contains("m")?"      "+b:x<=n?a[n]+b:new string(' ',j[Math.Abs(9-x)])+b+a[n].Replace(" ","");foreach(var c in a){Console.WriteLine(c);}}}

Ungolfed (inclui loop!)

class Program {
    public static string[] moon = new string[] { "               ", "      mmm      ", "    mmmmmmm    ", "   mmmmmmmmm   ", "    mmmmmmm    ", "      mmm      ", "               " };

    public static string bat = "^o^";

    static void Main(string[] args) {
        while (true) {
            Fly();
        }
    }

    static void Fly() {
        int times = (moon.Length * 2) - 1;
        for (int x = 0; x < times; x++) {
            string[] temp = (string[])moon.Clone(); //create a new array to maintain the original

            int index = x >= moon.Length ? times - x - 1 : x;

            if (!temp[index].Contains("m")) {
                temp[index] = new string(' ', 6) + bat + new string(' ', 6);
            } else if (x <= index) {
                int lastM = temp[index].LastIndexOf('m') + 1;
                temp[index] = temp[index].Insert(lastM, bat);
            } else {
                int firstM = temp[index].IndexOf('m');
                char[] src = temp[index].ToCharArray();
                int i = firstM - bat.Length;
                src[i] = bat[0];
                src[i + 1] = bat[1];
                src[i + 2] = bat[2];

                temp[index] = new string(src);
            }

            for (int y = 0; y < temp.Length; y++) {
                Console.WriteLine(temp[y]);
            }
            Thread.Sleep(100);
            Console.Clear();
        }            
    }
}

Editar:

Retirou 21 bytes removendo espaços à direita na declaração da matriz. Em vez de uma grade com 15 caracteres de largura, cada linha é larga o suficiente para caber o bastão. Foram removidos outros 12 para a sequência desnecessária [] args emMain() declaração.

Edição 2:

Reescreva a maior parte da lógica, eliminando 245 bytes! Inclui alterações sugeridas nos comentários. Obrigado!

A partir dos comentários, transformou isso em uma função em M()vez do Main()método anterior - agora, isso precisa ser chamado externamente.

Python 2, 299 300 290 270 bytes

Jogou até 270, ganhando um pouco mais de experiência no golfe.

Implementação de referência desenvolvida por 321 320 330 bytes. Não é bonito ou elegante. Apenas usa seqüência de força bruta e fatiamento de lista. Foi divertido diminuir a contagem de bytes, mas acho que a abordagem estava completamente errada para um concorrente sério.

Não espero que esta resposta seja levada a sério, por isso não há votos negativos. Eu disse na pergunta que tentaria jogar golfe na implementação de referência e é exatamente isso. Apenas postado por diversão.

c,e,n=' ','m','\n';f,g=c*9+e*3+c*9,c*7+e*7+c*7;h=9,12;i=12,15;j=6,9;k=13,17;l=4,7;m=c*21,f,g,c*6+e*9+c*6,g,f,c*21;p=h,i,k,(15,18),k,i,h,j,l,(3,6),l,j,h;w=0
for z in map(int,'0123456543210'):print n.join(m[:z])+n+m[z][:p[w][0]]+'^o^'+m[z][p[w][1]:]+n+n.join(m[z+1:]);w+=1

Experimente online!

Ruby, 164 156 bytes

puts Zlib.inflate Base64.decode64 "eNqlkrUVAAEMQvtMcZP9DfLYvzo3qhNSxQ2GVRC1ad29ar1JXaoHbul16Yig+p6BCKqtFBFU+1IE1famoHrX/jZBvN8e8f5tiE94Ib4SBREwNKH5BNJy2QM="

Programa muito simples. Pode ser trabalhado em mais. Por favor, deixe dicas nos comentários.

///, 205 bytes

/*/\/\///B/^o^*9/         
*M/mmm*N/MM*O/   *0/OO*n/

*1/O Nm0
*2/NM0
*3/0M9*4/1O2*7/13n*5/34/0B9570MB0
473O NmBO 
O2731ONMBO
75O NmBO 
3n510MB0n
5130B9n51OBM9n5 BNm0 
3n31B273 BNm0 
O27OBM9470B90M0O
410MO

Try it online!

Only if I didn't need tons of trailing spaces...

Mumps, 223 Bytes

This is using InterSystems Cache Mumps -- it allows braces around loops which make it handy for nested loops in a single line.

S X="09121415141209060403040609",R="097679",L="037973",S=-14 F Y=1:1:13 S S=S+2 F C=1:1:7 S F=$E(X,Y*2-1,Y*2),(M,T)="",$P(T," ",21)="" F A=1:1:$E(L,C){S M=M_"m"} S $E(T,$E(R,C))=M S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^" W T,!

Could probably be golfed more, and I may play with that when I have more time. Add another 9 bytes, and it'll be animated [[ due to the addition of the 'H 1 W # ' --> that halts for a second and clears the screen:

S X="09121415141209060403040609",R="097679",L="037973",S=-14 F Y=1:1:13 S S=S+2 H 1 W # F C=1:1:7 S F=$E(X,Y*2-1,Y*2),(M,T)="",$P(T," ",21)="" F A=1:1:$E(L,C){S M=M_"m"} S $E(T,$E(R,C))=M S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^" W T,!

Here's an ungolfed / explained version (of the animation version), with the correct 'do' statements and dot loops:

 S X="09121415141209060403040609"
 S R="097679",L="037973",S=-14              ; Initialize Variablex
 F Y=1:1:13 D                               ; Set up our main loop of 13 cels
 . S S=S+2                                  ; set up secondary counter, for start char.
 . H 1                                      ; halt for 1 second
 . W #                                      ; clear screen
 . F C=1:1:7 D                              ; set up our per-line loop
 . . S F=$E(X,Y*2-1,Y*2)                    ; set F to 2-digit "start of bat"
 . . S (M,T)=""                             ; set our "builder" lines to empty strings
 . . S $P(T," ",21)=""                      ; then reset our main 'line string' to 21 spaces.
 . . F A=1:1:$E(L,C){S M=M_"m"}             ; make our 'moon' text.
 . . S $E(T,$E(R,C))=M                      ; and insert our 'moon' into the empty line
 . . S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^"  ; find the start character for our 'bat' and insert.
 . . W T,!                                  ; and write the line and a CR/LF.

I tried to do the "compress then Base-64 encode" jazz just to see what would happen, but the encoded string ended up a little longer than the program itself! That, and Cache's system calls for the compression and base64 encoding are quite long... for example, here's the system call to decode base64: $System.Encryption.Base64Decode(STRING)

That method would 'bloat' the program to over 300 characters, I think...