Regras:

• Qualquer idioma que você escolher (bibliotecas padrão).
• Saída exibida no Terminal ou no Windows Command Processor ou de qualquer outra maneira que você preferir.
  (buffer de largura = 80)
• Caracteres ASCII são suficientes. (pode adicionar Unicode)
• Não deve preencher a tela inteira na inicialização (deve parecer uma chuva, duh!).
• Cores ganha pontos de bônus (+5).
• Efeitos : Caracteres aleatórios, diferentes tamanhos de queda, são regenerados periodicamente.
  

Pontos: (atualização)

• +32 pontos para começar.
• -1 ponto para cada byte (não caracteres) no código após o ** 1024 *** th * byte.
• Os pontos podem chegar a zero e negativos.
• Nota: Os idiomas que usam caracteres multibyte devem contar bytes, não caracteres.
• +5 para cada novo efeito. (não publicado por outras pessoas)
• +15 para qualquer um destes efeitos:
  1. Vento (sopra caracteres para o lado)
  2. Correspondência de números (entrada do usuário, por exemplo: 90210): o
     número é localizado aleatoriamente na matriz
     
  3. Som
  4. Mensagem criptografada (entrada do usuário): os
     caracteres representam uma mensagem criptografada secreta
  5. Modo Galaga:
     Dispara ^ para destruir personagens
     

Placar:

┌-----┬------------┬------------┬-------------┬---------------┬--------------┐
| pos |    name    |    type    |    bytes    |    effects    |    points  ^ |
|-----|------------|------------|-------------|---------------|--------------|
|1    |nitro2k01   |QBasic      |913          |Colours        |+57           |
|     |            |            |             |Colour Fade    |              |
|     |            |            |             |Sound (+15)    |              |
|-----|------------|------------|-------------|---------------|--------------|
|2    |squeamish   |HTML, Java- |1024         |Colours        |+47           |
|     |ossifrage   |Script, CSS |             |Transition     |              |
|     |            |            |             |Size Variation |              |
|-----|------------|------------|-------------|---------------|--------------|
|3    |manatwork   |Ruby        |374          |Colours        |+47           |
|     |            |            |             |Actual Words   |              |
|     |            |            |             |Character -    |              |
|     |            |            |             |      Disperse |              |
|-----|------------|------------|-------------|---------------|--------------|
|4    |plg         |Bash        |1024         |Colours        |+42           |
|     |            |            |             |Random Pause   |              |
|-----|------------|------------|-------------|---------------|--------------|
|5    |Timtech     |TI-84 calc  |120          |Umbrella       |+42           |
|     |            |            |             |Run Inside     |              |
|-----|------------|------------|-------------|---------------|--------------|
|6    |Samuel Cook |JavaScript  |830          |Colours        |+42           |
|     |            |            |             |Transition     |              |
└-----┴------------┴------------┴-------------┴---------------┴--------------┘

Nota: O painel de avaliação será / poderá ser atualizado por qualquer pessoa após publicar uma resposta válida. Não exceda as dez primeiras posições. Adicione mais efeitos ao seu código e supere sua própria pontuação!
Limpar a tela inicial, limpeza, bugs, bibliotecas de terceiros etc. não conta para os pontos Lembre-se de incluir detalhes sobre não. de bytes usados ​​e o nome do idioma ou programa.

Neo: O que você está tentando me dizer? Que eu posso evitar balas?

Morfeu: Não, Neo. Estou tentando lhe dizer que quando estiver pronto, você não precisará.

HTML, Javascript e CSS: 1024 bytes, 47 pontos

Recursos:

• Usa caracteres Unicode (embora não ache que isso marque pontos)
• As trilhas desaparecem do verde brilhante para o verde escuro enquanto estão sendo desenhadas (*)
• As trilhas também desaparecem do verde escuro para o preto após a conclusão do desenho (*)
• Tamanho aleatório do texto em cada trilha (*)
• As trilhas são reposicionadas aleatoriamente e redimensionadas toda vez que são desenhadas

(*) Vou reivindicar +5 pontos para cada um deles, mas deixe-me saber se você não concorda :-)

Demo:

http://ruletheweb.co.uk/matrix.html

Código fonte:

Exatamente 1024 bytes. É um pouco feio, receio.

<head><style>*{margin:0;padding:0;line-height:1;overflow:hidden;}div{width:1em;position:absolute;}</style><script>
w=window;n=w.innerWidth;m=w.innerHeight;d=document;q="px";function z(a,b){return Math.floor(Math.random()*(b-a)+a)}f=" 0123456789";for(i=0;i<45;i++)f+=String.fromCharCode(i+65393);function g(){for(i=0;i<90;i++){r=d.createElement("div");for(j=z(20,50);j;j--){x=d.createElement("pre");y=d.createTextNode(f[z(0,56)]);x.appendChild(y);x.style.opacity=0;r.appendChild(x)}r.id="r"+i;r.t=z(-99,0);with(r.style){left=z(0,n)+q;top=z(-m,0)+q;fontSize=z(10,25)+q}d.body.appendChild(r);setInterval("u("+i+")",z(60,120))}}function u(j){e=d.getElementById("r"+j);c=e.childNodes;t=e.t+1;if((v=t-c.length-50)>0){if((e.style.opacity=1-v/32)==0){for(f in c)if(c[f].style)c[f].style.opacity=0;with(e.style){left=z(0,n)+q;top=z(-m/2,m/2)+q;opacity=1}t=-50}}e.t=t;if(t<0||t>c.length+12)return;for(f=t;f&&f>t-12;f--){s=1-(t-f)/16;if(f<c.length&&c[f].style){c[f].style.opacity=s;}}}
</script><body text=#0f0 bgcolor=#000 onload=g()>

Bater

1024 bytes (incluindo comentários)

COL=80
ROW=$(tput lines)

cleanup() {
  wait # wait for background jobs (the drops)
  # clear; move cursor to (1,1); show cursor
  # reset color
  printf '\033[2J\033[1;1H\033[?25h\033[0;0m'
}

drop() { # $1=column ; $2=row to end on ; $3 = drop size (ranges from 5 to 15)
  for ((r=1; r<$2+$3+1; r++)); do
    # if before drop's end point : print lowest char in white
    [ $r -lt $2 ] && printf "\033[$r;$1H\033[0;0m\u$[RANDOM % 59 + 21]"

    # if before or on drop's end point : replace older white char with a green one
    [ $r -le $2 ] && printf "\033[$[r-1];$1H\033[0;32m\u$[RANDOM % 59 + 21]"

    # if drop's longer than it's size : erase last char
    [ $r -gt $3 ] && printf "\033[$[r-$3];$1H "

    # wait before moving drop down
    sleep .1
  done
}

# cleanup on exit
trap cleanup EXIT
# clear screen; hide cursor
printf '\033[2J\033[?25l'

# loop with delay
while sleep .1; do
  # start a drop in background : column; ending row; size
  drop $[RANDOM % COL] $[RANDOM % ROW + ROW/3] $[RANDOM % 10 + 5] &
done

Novos efeitos:

• tudo (primeira entrada);)
• gotas irão parar aleatoriamente na tela
• efeitos de cores legais: o último caractere é branco enquanto os outros são verdes
• caracteres aleatórios e seqüências de escape permanecem no console ... Ok, isso é um bug, mas é porque o termo não pode acompanhar o movimento do cursor

Golfed @ 188 186 176 :

d(){ for((r=1;r<$2+41;r++));do $4"$3$r;$1H\u$[RANDOM%59+21]";(($r>$2))&&$4"$3$[r-$2];$1H ";$s;done;}
s=sleep\ .1;while $s;do d $[RANDOM%80] $[RANDOM%10+5] '\033[' printf\ &done

Isso funciona em uma grade de 80x40. Você pode mudar isso na RANDOM%80última linha e r<$2+41na segunda. Eu não limpo as gotas depois que elas saem da grade, então redimensione seu prazo para 80x40 ou altere 41 para $LINES+1. Existem algumas coisas que não têm em comparação com a versão completa:

• preparação ou limpeza a termo
• coloração chique (leva 52 bytes, então não vale a pena)
• parando aleatoriamente (aqui as gotas sempre descem para o fundo)
• Eu poderia reduzi-lo a 174 não especificando um comprimento mínimo para "gotas": $[RANDOM%10+5]ficaria$[RANDOM%15]

Mesmo com essas limitações, acho bem legal!

Edit: Eu tentei usar caracteres unicode como ossifrage melindroso, mas porque eles são caracteres de largura dupla, eles preenchem a grade rapidamente e isso acaba parecendo estranho.

Também reduzi a versão golfed usando pontos de código unicode em vez de ASCII, para não precisar octal antes de obter um caractere, salvando uma etapa. Fiz a mesma coisa na versão principal, mas adicionei comentários para mantê-lo em 1024 bytes.

E então mudei a comparação int de [ $r -gt $2 ]para (($r>$2)), esse espaço em branco estava me matando, mas não consegui encontrar outro método que comparasse ints e não strings. Isso reduziu a versão para 176 btyes!

JavaScript, 830 bytes

Possui todos os recursos clássicos, como:

1. fundo preto
2. texto verde
3. texto em branco ao cair
4. caracteres aleatórios
5. buracos vazios
6. loop infinito

window.onload=function(){
    var tbl=document.createElement('table'),
	body=document.body;
	body.style.backgroundColor='#000';
	body.style.color='#060';
	body.style.fontFamily='Lucida Console';

    for(var i = 0; i <= 30; i++){
        var tr = tbl.insertRow();
        for(var j = 0; j <= 50; j++){
            var td = tr.insertCell();
			td.style.width="2%";
        }
    }
    body.appendChild(tbl);
	setInterval(function(){
		rain(Math.floor((Math.random()*50)),0)
	},20);
}
function rain(n,i) {          
   setTimeout(function (){
	  var e=document.getElementsByTagName('tr')[i].childNodes[n];
	  e.style.color='#fff';
      e.innerHTML = '&#'+Math.floor((Math.random()*127)+1)+';';
	  setTimeout(function(){e.style.color=''},200)
	  
      if (i++ < 30) rain(n,i);
   },20);
};

Gosto porque é incrivelmente leve, fluido em movimento e simples. desfrutar!

QBasic 1, 587 bytes, 32 + 5 = 37 pontos

DECLARE SUB d (p!, s!, x!, y!)
DIM t(80)
FOR i = 1 TO 80
    t(i) = INT(-50 * RND)
NEXT
s = TIMER

CLS
WHILE 1
    FOR i = 1 TO 80
        IF t(i) > 28 THEN t(i) = 0
        t(i) = t(i) + 1
        y = t(i)
        d 0, 0, i, y - 6
        d 2, 0, i, y - 5
        d 2, 0, i, y - 4
        d 10, 0, i, y - 3
        d 10, 0, i, y - 2
        d 11, 0, i, y - 1
        d 0, 2, i, y
    NEXT

    l = TIMER
    WHILE l = TIMER
    WEND
WEND

SUB d (p, s, x, y)
COLOR p, s
IF y > 0 AND y < 24 THEN LOCATE y, x: PRINT CHR$(33 + (x * y) MOD 200);
END SUB

Exemplo de captura de tela:

32 pontos base + 5 pontos por cor. Mas como estou flutuando alegremente bem abaixo de 1024 bytes, mesmo sem a remoção ou otimização de espaço em branco, vamos adicionar mais algumas coisas para roubar alguns pontos:

QBasic 2, 913 bytes, 32 + 5 + 15 + 5 = 57 pontos

DECLARE SUB d (p!, s!, x!, y!)
DIM t(80)
FOR i = 1 TO 80
    t(i) = INT(-50 * RND)
NEXT
s = TIMER
f = 0
w$ = "bullet"
o = 1
CLS
WHILE 1
    FOR i = 1 TO 80
        IF t(i) > 28 THEN t(i) = 0: IF f THEN SOUND 100 * i, 1
        t(i) = t(i) + 1
        y = t(i)
        d 0, 0, i, y - 6
        d 2 + x, 0, i, y - 5
        d 2 + x, 0, i, y - 4
        d 10 + x, 0, i, y - 3
        d 10 + x, 0, i, y - 2
        d 11 + x, 0, i, y - 1
        d 0, 2 + x, i, y
    NEXT
    k$ = INKEY$
    IF k$ <> "" THEN
        IF MID$(w$, o, 1) = k$ THEN
            o = o + 1
            IF o = LEN(w$) + 1 THEN z = 1: f = 100
        ELSE
            o = 1
        END IF

    END IF
    x = x + z
    l = TIMER
    WHILE l = TIMER
    WEND

WEND

SUB d (p, s, x, y)
COLOR p MOD 16, s MOD 16
IF y > 0 AND y < 24 THEN LOCATE y, x: PRINT CHR$(33 + (x * y) MOD 200);
END SUB

Captura de tela de amostra (efeito de cor ativado):

Mesmos recursos que o primeiro. Além disso, possui:

• Cor (+5)
• Uma senha para ativar recursos extras. (Estou reivindicando +5 para isso como um novo recurso.)
• A senha ativa uma paleta desbotada e efeitos sonoros. (+15 para som.)

Vídeo mostrando-o em ação, incluindo o efeito de cor e efeito de som ativado pela senha:

http://www.youtube.com/watch?v=MQc-FDl_AZ8

GTB , 42 pontos

Executado a partir de uma calculadora TI-84, cerca de 100 bytes:

"  O O    O O   O"→Str1:"O  O   O O  O O "→Str2:0→X[@getkey=25$~""~""~""~""~""~""~""p;&@round(r;$~""#@round(r;$~Str1#~Str2&:&]

Efeitos

Como a calculadora é preto + branco, para começar, não há muito o que fazer ...

• Guarda - chuva - Pressionar a tecla para cima limpa a chuva e mantém você seco até pressionarEnter
• Run Inside - Pressionar ONinterrompe o programa e oferece um belo teto para mantê-lo seco (você pode voltar para a chuva pressionando Enterduas vezes

Ruby: 374 caracteres

$><<"^[[2J"
w=->c,d,m{$><<"^[[0;3%d;%dm^[[%d;%dH%s"%[c,d[4],d[3]+d[1]-m,d[2],d[0][d[1]-m]]}
t=%w{Stack Exchange Programming Puzzle Code Golf}
r=[]
loop{r.map{|o|w[2,o,1]if o[1]>0
w[7,o,0]
o[1]+=1
o[0][0]==" "?r.delete(o):(o[0]=" "*o[1])*o[1]=0if o[1]>o[0].size}
sleep 0.1
r<<[(k=rand(10)%2)==0 ?t.sample: [*?a..?z].sample(rand(10)+5)*"",0,rand(80),rand(20),k+1]while r.size<25}

(Nota: ^[são caracteres únicos.)

Descrição:

• 25 execuções simultâneas (mantidas baixas para que os textos predefinidos permaneçam legíveis)
• cada corrida tem 50% / 50% de chance de ser
  • uma palavra predefinida - exibida em cores brilhantes
  • uma sequência aleatória de 5 a 15 letras minúsculas - exibida em cores escuras
• enquanto exibe a corrida, a cor inferior é branca, as outras verdes
• depois que a corrida é totalmente exibida, ela é removida caractere por caractere

Exemplo de execução: