Regole:

• Qualsiasi lingua tu scelga (Librerie standard).
• Output visualizzato nel terminale o nell'elaboratore di comandi di Windows o in qualsiasi altro modo tu preferisca.
  (buffer larghezza = 80)
• I caratteri ASCII sono sufficienti. (può aggiungere Unicode)
• Non dovrebbe riempire l'intero schermo all'avvio (dovrebbe sembrare una pioggia, duh!).
• I colori ottengono punti bonus (+5).
• Effetti : personaggi casuali, diverse dimensioni di caduta, si rigenera periodicamente.
  

Punti: (aggiornamento)

• +32 punti per cominciare.
• -1 punto per ogni byte (non caratteri) nel codice dopo il ** 1024 *** th * byte.
• I punti potrebbero raggiungere zero e negativi.
• Nota: le lingue che usano caratteri multibyte devono contare byte non caratteri.
• +5 per ogni nuovo effetto. (non pubblicato da altri)
• +15 per uno di questi effetti:
  1. Vento (soffia i personaggi a lato)
  2. Corrispondenza numerica (input dell'utente, ad es .: 90210): il
     numero si trova casualmente all'interno della matrice
     
  3. Suono
  4. 
     Messaggio crittografato (input dell'utente): i caratteri rappresentano un messaggio crittografato segreto
  5. Modalità Galaga:
     spara ^ per distruggere i personaggi
     

Pagelle:

┌-----┬------------┬------------┬-------------┬---------------┬--------------┐
| 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: il quadro di valutazione sarà / potrebbe essere aggiornato da chiunque dopo aver pubblicato una risposta valida. Non superare le prime dieci posizioni. Aggiungi più effetti al tuo codice e batti il ​​tuo punteggio!
L'eliminazione della schermata iniziale, la pulizia, i bug, le librerie di terze parti ecc. Non contano ai fini. Ricordarsi di includere i dettagli relativi al n. di byte utilizzati e il nome della lingua o del programma.

Neo: cosa stai cercando di dirmi? Che posso schivare i proiettili?

Morpheus: No, Neo. Sto cercando di dirti che quando sarai pronto, non dovrai farlo.

HTML, Javascript e CSS: 1024 byte, 47 punti

Caratteristiche:

• Utilizza caratteri Unicode (non pensare che questo ottenga punti)
• I tracciati sfumano dal verde chiaro al verde scuro mentre vengono disegnati (*)
• Anche i tracciati svaniscono dal verde scuro al nero al termine del disegno (*)
• Dimensione del testo casuale in ogni traccia (*)
• Le tracce vengono riposizionate e ridimensionate casualmente ogni volta che vengono disegnate

(*) Richiederò +5 punti per ognuno di questi, ma fammi sapere se non sei d'accordo :-)

demo:

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

Codice sorgente:

Esattamente 1024 byte. È un po 'brutto, temo.

<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()>

bash

1024 byte (compresi i commenti)

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

Nuovi effetti:

• tutto (prima voce);)
• le gocce si fermeranno casualmente sullo schermo
• fantastici effetti di colore: l'ultimo carattere è bianco mentre gli altri sono verdi
• caratteri casuali e sequenze di escape rimangono sulla console ... Ok, questo è un bug ma è perché il termine non può tenere il passo con il movimento del cursore

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

Funziona in una griglia 80x40. Puoi cambiarlo RANDOM%80nell'ultima riga e r<$2+41nella seconda. Non elimini le gocce dopo che sono uscite dalla griglia, quindi ridimensiona il termine a 80x40 o cambia 41 in $LINES+1. Ci sono un paio di cose che non ha rispetto alla versione completa:

• preparazione a termine o pulizia
• colorazione fantasia (richiede 52 byte, quindi non ne vale la pena)
• fermarsi casualmente (qui le gocce vanno sempre in fondo)
• Potrei ridurlo a 174 non specificando una lunghezza minima per "gocce": $[RANDOM%10+5]diventerebbe$[RANDOM%15]

Anche con queste limitazioni, penso che sia abbastanza bello!

Modifica: ho provato a usare i caratteri unicode come l'ossifrage schizzinoso, ma poiché sono caratteri a doppia larghezza riempiono la griglia abbastanza rapidamente e finisce per sembrare strano.

Ho anche ridotto la versione golfizzata usando punti di codice unicode invece di ASCII, quindi non devo andare ottale prima di ottenere un personaggio, salvando un passo. Ho fatto la stessa cosa nella versione principale, ma ho aggiunto commenti per mantenerlo a 1024 byte.

E poi cambiato il confronto int da [ $r -gt $2 ]a (($r>$2)), quello spazio bianco mi stava uccidendo ma non riuscivo a trovare un altro metodo che mettesse a confronto gli ints e non le stringhe. Questo ha portato la versione golfata a 176 btyes!

JavaScript, 830 byte

Ha tutte le caratteristiche classiche come:

1. sfondo nero
2. testo verde
3. testo bianco in caso di caduta
4. personaggi casuali
5. buchi vuoti
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);
};

Mi piace perché è incredibilmente leggero, fluido nel movimento e semplice. godere!

QBasic 1, 587 byte, 32 + 5 = 37 punti

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

Schermata di esempio:

32 punti base + 5 punti per il colore. Ma poiché sto galleggiando felicemente ben al di sotto di 1024 byte anche senza il taglio o l'ottimizzazione degli spazi bianchi, aggiungiamo alcune altre cose per rubare alcuni punti:

QBasic 2, 913 byte, 32 + 5 + 15 + 5 = 57 punti

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

Schermata di esempio (effetto colore attivato):

Stesse funzionalità della prima. Inoltre ha:

• Colore (+5)
• Una password per attivare funzionalità extra. (Sto rivendicando +5 per questo come una nuova funzionalità.)
• La password attiva una tavolozza dissolvenza ed effetti sonori. (+15 per il suono.)

Video che lo mostra in azione, inclusi l'effetto colore e l'effetto sonoro attivati ​​dalla password:

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

GTB , 42 punti

Eseguito da una calcolatrice TI-84, circa 100 byte:

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

effetti

Poiché la calcolatrice è in bianco + nero per cominciare, non può fare molto lì ...

• Ombrello : premendo il tasto Su si elimina la pioggia e si mantiene asciutti finché non si premeEnter
• Esegui all'interno - Premendo si ONinterrompe il programma e ti dà un bel tetto per tenerti asciutto (puoi tornare fuori sotto la pioggia premendo Enterdue volte

Rubino: 374 caratteri

$><<"^[[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: ^[sono singoli caratteri.)

Descrizione:

• 25 corse simultanee (mantenute basse in modo che i testi predefiniti rimangano leggibili)
• ogni corsa ha una probabilità del 50% / 50% di esserlo
  • una parola predefinita - visualizzata con colori vivaci
  • una stringa casuale di 5..15 lettere minuscole - visualizzate in colori scuri
• mentre mostra la corsa il colore di fondo è bianco, gli altri verdi
• dopo che la corsa è stata completamente visualizzata, viene rimossa carattere per carattere

Esecuzione di esempio: