Regeln:

• Beliebige Sprache (Standardbibliotheken).
• Die Ausgabe wird im Terminal oder im Windows-Befehlsprozessor oder auf eine andere von Ihnen bevorzugte Weise angezeigt .
  (Breitenpuffer = 80)
• ASCII- Zeichen sind genug. (kann Unicode hinzufügen)
• Sollte beim Start nicht den gesamten Bildschirm ausfüllen (sollte wie ein Regen aussehen, duh!).
• Farben erhalten Bonuspunkte (+5).
• Effekte : Zufällige Zeichen, unterschiedliche Fallgrößen, werden regelmäßig neu generiert.
  

Punkte: (Update)

• +32 Punkte für den Anfang.
• -1 Punkt für jedes Byte (nicht Zeichen) im Code nach dem ** 1024 *** -ten * Byte.
• Punkte können null und negativ erreichen.
• Hinweis: Sprachen, die Multibyte-Zeichen verwenden, sollten Bytes und keine Zeichen enthalten.
• +5 für jeden neuen Effekt. (nicht von anderen gepostet)
• +15 für einen dieser Effekte:
  1. Wind (bläst Zeichen zur Seite)
  2. Nummernvergleich (Benutzereingabe, zB: 90210): Die
     Nummer befindet sich zufällig in der Matrix
     
  3. Klingen
  4. Verschlüsselte
     Nachricht (Benutzereingabe): Zeichen stehen für eine geheime verschlüsselte Nachricht
  5. Galaga-Modus:
     Feuert ^ ab, um Charaktere zu zerstören
     

Anzeigetafel:

┌-----┬------------┬------------┬-------------┬---------------┬--------------┐
| 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     |              |
└-----┴------------┴------------┴-------------┴---------------┴--------------┘

Hinweis: Die Anzeigetafel kann / wird von jedermann aktualisiert, nachdem eine gültige Antwort abgegeben wurde. Überschreiten Sie nicht die zehn besten Positionen. Fügen Sie Ihrem Code weitere Effekte hinzu und übertreffen Sie Ihre eigene Punktzahl!
Das Löschen des Startbildschirms, Bereinigen, Bugs, Bibliotheken von Drittanbietern usw. wird nicht für die Punkte angerechnet. der verwendeten Bytes und der Name der Sprache oder des Programms.

Neo: Was versuchst du mir zu sagen? Dass ich Kugeln ausweichen kann?

Morpheus: Nein, Neo. Ich versuche Ihnen zu sagen, dass Sie es nicht müssen, wenn Sie bereit sind.

HTML, Javascript und CSS: 1024 Bytes, 47 Punkte

Eigenschaften:

• Verwendet Unicode-Zeichen (glaube aber nicht, dass dies Punkte bringt)
• Die Spuren verblassen während des Zeichnens von hell zu dunkelgrün (*)
• Die Spuren verblassen auch nach Abschluss der Zeichnung von dunkelgrün nach schwarz (*)
• Zufällige Textgröße in jeder Spur (*)
• Die Trails werden bei jedem Zeichnen zufällig neu positioniert und in der Größe angepasst

(*) Ich werde jeweils +5 Punkte einfordern, aber lass es mich wissen, wenn du nicht einverstanden bist :-)

Demo:

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

Quellcode:

Genau 1024 Bytes. Es ist ein bisschen hässlich, fürchte ich.

<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 Bytes (einschließlich Kommentare)

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

Neue Effekte:

• alles (erster eintrag);)
• Tropfen stoppen zufällig auf dem Bildschirm
• coole Farbeffekte: Der letzte Saibling ist weiß, während die anderen grün sind
• Zufällige Zeichen und Escape-Sequenzen bleiben auf der Konsole ... Ok, das ist ein Fehler, aber der Begriff kann nicht mit der Cursor-Bewegung mithalten

Golf @ 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

Dies funktioniert in einem 80x40-Raster. Sie können dies in RANDOM%80der letzten und r<$2+41in der zweiten Zeile ändern . Ich lösche die Tropfen nicht, nachdem sie aus dem Raster verschwunden sind, also ändern Sie entweder die Größe Ihrer Laufzeit auf 80x40 oder die von 41 auf $LINES+1. Es gibt ein paar Dinge, die es im Vergleich zur Vollversion nicht hat:

• Term Vorbereitung oder Bereinigung
• ausgefallene Färbung (dauert 52 Bytes, also nicht wert)
• Zufälliges Anhalten (hier fallen die Tropfen immer nach unten)
• Ich könnte es auf 174 reduzieren, indem ich keine Mindestlänge für "Drops" spezifiziere: $[RANDOM%10+5]würde werden$[RANDOM%15]

Trotz dieser Einschränkungen finde ich es ziemlich cool!

Bearbeiten: Ich habe versucht, Unicode-Zeichen wie zimperliches Ossifrage zu verwenden, aber da es sich um Zeichen mit doppelter Breite handelt, füllen sie das Gitter ziemlich schnell und es sieht seltsam aus.

Ich habe auch die Golf-Version reduziert, indem ich Unicode-Codepunkte anstelle von ASCII verwendet habe, sodass ich nicht ins Oktal wechseln muss, bevor ich einen Charakter bekomme und einen Schritt speichere. Ich habe dasselbe in der Hauptversion gemacht, aber Kommentare hinzugefügt, um es bei 1024 Bytes zu halten.

Und dann änderte sich im Vergleich von [ $r -gt $2 ]zu (($r>$2)), dass der weiße Raum mich tötete, aber ich konnte keine andere Methode finden, die Ints und nicht Strings verglich. Dies brachte die Golfversion auf 176 Btyes!

JavaScript, 830 Byte

Es hat alle klassischen Funktionen wie:

1. schwarzer Hintergrund
2. grüner Text
3. weißer Text beim Fallen
4. zufällige Zeichen
5. leere Löcher
6. Endlosschleife

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);
};

Ich mag es, weil es unglaublich leicht, flüssig in der Bewegung und einfach ist. genießen!

QBasic 1, 587 Bytes, 32 + 5 = 37 Punkte

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

Beispielbild:

32 Basispunkte + 5 Punkte für Farbe. Da ich aber auch ohne Leerzeichen-Beschneidung oder -Optimierung deutlich unter 1024 Byte schwebe, fügen wir noch ein paar Dinge hinzu, um einige Punkte zu stehlen:

QBasic 2, 913 Bytes, 32 + 5 + 15 + 5 = 57 Punkte

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

Beispielbild (Farbeffekt aktiviert):

Gleiche Funktionen wie die erste. Zusätzlich hat es:

• Farbe (+5)
• Ein Passwort, um zusätzliche Funktionen zu aktivieren. (Ich beanspruche +5 dafür als neues Feature.)
• Das Passwort aktiviert ein Palettenfade und Soundeffekte. (+15 für Ton.)

Video, das es in Aktion zeigt, einschließlich des durch das Passwort aktivierten Farb- und Soundeffekts:

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

GTB , 42 Punkte

Von einem TI-84-Rechner ausgeführt, ungefähr 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&:&]

Auswirkungen

Da der Rechner anfangs schwarz + weiß ist, kann man da nicht viel machen ...

• Regenschirm - Durch Drücken der Aufwärtstaste wird der Regen gelöscht und Sie bleiben trocken, bis Sie drückenEnter
• Innen rennen - Drücken von ONunterbricht das Programm und gibt Ihnen ein schönes Dach, um Sie trocken zu halten (Sie können wieder in den Regen gehen, indem Sie Enterzweimal drücken

Ruby: 374 Zeichen

$><<"^[[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}

(Hinweis: ^[ sind einzelne Zeichen.)

Beschreibung:

• 25 gleichzeitige Durchläufe (gering gehalten, damit die vordefinierten Texte lesbar bleiben)
• Jeder Lauf hat eine Chance von 50% / 50%
  • ein vordefiniertes Wort - in leuchtenden Farben angezeigt
  • eine zufällige Zeichenfolge aus 5..15 Kleinbuchstaben - in dunklen Farben angezeigt
• Während der Lauf angezeigt wird, ist die untere Farbe weiß, die anderen grün
• Nachdem der Lauf vollständig angezeigt wurde, wird er zeichenweise entfernt

Probelauf: