Patlayan bir piksel grubunu ekrandan ayıran bir program yazabilir misiniz (basit bir parçacık motorunda olduğu gibi) ve bunu çok az sayıda karakterde (tuş vuruşları) yapabilir misiniz? (Bu küçük adamların patlayacağı ve küçük piksel parçalarının parçalandığı zaman oyun lemmings'i hatırlayın.)

Birisi burada basit bir parçacık sistemini bir İşleme taslağı olarak programladı ve başkalarının denerse başarabilmeleri gerektiğini düşündüğümle karşılaştırıldığında oldukça ağır. Ama birisi c ++ ve sdl, hatta java veya c # ile aynı şeyi yapabilirse çok daha etkilendim.

Python, 245 karakter

import random,time
R=lambda:random.randrange(-999,999)/1e3
P=[(40+20j,R()+1j*R())for i in' '*20]
for i in' '*20:
 C=([' ']*80+['\n'])*40
 for p,v in P:C[int(p.real)+81*int(p.imag)]='*'
 print''.join(C);P=[(p+v,v*.95)for p,v in P];time.sleep(.1)

C #, WPF - 1523

Çok ciddi değil; bu aslında işe yarayıp yaramadığı bir girişimdi.

Burada yaptığım veri bağlama ve şablonlama ile parçacıkları görüntülemek için WPF bir ItemsControl (daha kısa olduğu için Menü) kullanmaktır. Bir veri şablonu parçacıkların nasıl göründüğünü (bu durumda basit bir daire) kontrol eder ve veri bağlama parçacıkların rengini ve konumunu kontrol eder.

Her parçacığın bir zamanlayıcı tarafından güncellenen bir konumu, rengi ve yönü vardır. Başlangıçta, pencerenin merkezinde (normal dağılmış) rastgele yönlerle bir grup parçacık üretilir. Bu koleksiyon, daha sonra özellikler her güncellendiğinde parçacıkların otomatik olarak görüntülenmesini sağlayan ItemsControl'e veri ile bağlanır. Parçacıklar yerçekimi nedeniyle biraz aşağı sürüklenir.

Kuşkusuz biraz uzadı. Ama en azından güzel görünüyor:

Kesinlikle atlayarak daha kısa yapılabilir:

• yerçekimi, parçacıkların tüm taraflara eşit olarak genişlemesine neden olur;
• başlangıç ​​vektörleri için normal dağılım, parçacıkların seyrek bir »kutu« içinde genişlemesine neden olur;
• Parçacıkları siyah bırakarak parlaklık değişimi.

Estetik çıkarına bunu yapmamayı seçtim. Bu çözüm ne olursa olsun hemen hemen her şeyden çok daha uzundur. Veri bağlama ve şablonlama yaklaşımı zarif olabilir, ancak bir bitmap'in güncellenmesi ile karşılaştırıldığında oldukça ayrıntılıdır. (Not: Yukarıdakilerin hepsini dışarıda bırakarak 1356'ya indirdim , ama o zaman korkunç görünüyor.)

Kod, okunaklılık için burada biçimlendirilmiş biçimde verilen üç dosyaya dağıtılır:

App.xaml

<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" StartupUri="W.xaml"/>

W.xaml

<Window x:Class="W" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Menu Name="i">
        <Menu.ItemTemplate>
            <DataTemplate>
                <Ellipse Width="2" Height="2" Fill="#000" Opacity="{Binding O}">
                    <Ellipse.RenderTransform>
                        <TranslateTransform X="{Binding X}" Y="{Binding Y}"/>
                    </Ellipse.RenderTransform>
                </Ellipse>
            </DataTemplate>
        </Menu.ItemTemplate>
        <Menu.Template>
            <ControlTemplate>
                <ItemsPresenter/>
            </ControlTemplate>
        </Menu.Template>
        <Menu.ItemsPanel>
            <ItemsPanelTemplate>
                <Canvas/>
            </ItemsPanelTemplate>
        </Menu.ItemsPanel>
    </Menu>
</Window>

W.xaml.cs

using M = System.Math;
using T = System.Timers.Timer;
using System;
using System.ComponentModel;

partial class W
{
    int a;
    T t = new T(99);

    public W()
    {
        InitializeComponent();
        Height = Width = 500;
        var r = new Random();
        Func<double> n = () => 2 * (M.Sqrt(-2 * M.Log(r.NextDouble())) * M.Sin(6 * r.NextDouble()));
        var l = new System.Collections.Generic.List<P>();
        for (; a++ < 300; )
            l.Add(new P { X = 250, Y = 250, f = n(), g = n() });
        i.ItemsSource = l;
        t.Elapsed += delegate
        {
            foreach (P x in l)
            {
                x.X += x.f;
                x.Y += x.g += .2;
                x.O = M.Max(1 - M.Sqrt(M.Pow(250 - x.X, 2) + M.Pow(250 - x.Y, 2)) / 250, 0);
            }
        };
        t.Start();
    }
}

class P : System.Windows.ContentElement, INotifyPropertyChanged
{
    public double y, f, g;
    public double X { get; set; }
    public double O { get; set; }
    public double Y
    {
        get { return y; }
        set
        {
            y = value;
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(""));
        }
    }
    public event PropertyChangedEventHandler PropertyChanged;
}

postscript - 287244 karakter

currentpagedevice/q{exch def}def/PageSize get/z{dup 3 1 roll add exch 4 2 roll}def{2
div}forall/y/r{rand 2 27 exp div 8 sub}def q/x q[99{[x r y r]}repeat]50{dup{aload/t q
3 index 2 index 4 4 rectfill 1 sub z z t astore pop}forall showpage}repeat

ile koş gs -dNOPAUSE asplode.ps

Hatta yazdırabilir ve bir flipbook yapabilirsiniz

Javascript - 268 karakter

İşte 1 boyutlu, 2 parçacık, patlama:

javascript:d=document;c=d.createElement('canvas');d.body.appendChild(c);g=c.getContext("2d");function e(x,y,m){g.arc(x,y,m,0,2*Math.PI,false);g.fill()}function s(a,b,v,t){c.width=c.width;e(50+t*v,50,b);e(50+t*b*v/(b-a),50,a-b);setTimeout(function(){s(a,b,v,t+1)},100)};s(9,5,1,0)

Çalıştırmak için, iyi bir web tarayıcısında about: blank sayfasını açın, url çubuğuna yapıştırın ve enter tuşuna basın. Sonundaki değerleri düzenleyerek patlamayı değiştirebilirsiniz s(10,5,1,0). İlk değer, patlatılan parçacığın boyutudur. İkinci değer, patlayan parçacığın boyutudur. Üçüncü değer, patlayan parçacığın hızıdır. '0'ı olduğu gibi bırakın.

APL ( 120 118)

Python girişi ile aynı tür bir çıktıya sahiptir (yani, bir karakter ızgarasındaki durumları çıkarır). Yalnızca ızgara 30x15 ve parçacık orijini 15x7'dir.

⍎⊃,⌿(9⍴⊂'(⎕DL.1)⊢{{(A+2↑⍵),0.95×A←2↓⍵}¨⍵⊣⎕←'' ⍟''[1+(⍳15 30)∊2↑¨⌊⍵]}'),⊂',⌿⍉10 4⍴⍎''⍬'',420⍴'',(7 15,.01×99-?2⍴199)'''

JavaScript 502 500 496

Bu Joey ve david4dev'in cevaplarının bir kombinasyonudur ( Javascript / canvas ☺ kullanılarak uygulanan Joey algoritmasının utanmaz bir kopyasıdır):

W=500;H=250;function r(){return 2*m.sqrt(-2*m.log(m.random()))*m.sin(6*m.random())}function n(){z=[];for(i=W;i;i--){s={};s.x=s.y=H;s.f=r();s.g=r();z.push(s)}}function w(){x.clearRect(0,0,W,W);z.forEach(function(a){a.x+=a.f;a.y+=a.g+=.2;x.fillStyle="rgba(0,0,0,"+m.max(1-m.sqrt(m.pow(H-a.x,2)+m.pow(H-a.y,2))/H,0)+")";x.fillRect(a.x,a.y,2,2)})}z=[];m=Math;d=document;c=d.createElement("canvas");c.width=c.height=W;d.body.appendChild(c);x=c.getContext("2d");n();setInterval(n,2e3);setInterval(w,10)

JSFiddle önizlemesi: http://jsfiddle.net/GVqFr/60/ (kodu güzel bir şekilde biçimlendirmek için TidyUp düğmesine basabilirsiniz)

Bash 380

C="4443311177"
t=".-xxXMXxx-."
alias c='echo -e "\e[2J"'
g(){
echo -e "\e[1;$4\e[$2;$1H$3"
}
f(){
x=$1
y=$2
p=$((2-RANDOM%5))
q=$((2-RANDOM%5))
for i in {-5..5}
do
x=$((x+p))
y=$((y+q))
n=$((5+i))
c=$((5+i))
g $x $y ${t:n:1} 3${C:c:1}m 
w=$(printf "%04i\n" $((5*i*i)))
sleep ${w/0/0.}
g $x $y " " 3${C:c:1}m
done
}
e(){
c
for i in {1..10}
do
f $((COLUMNS/2)) $((LINES/2)) &
done
}

Patlat gibi e deyin.

güncelleme: renklendirilmiş

t = metin, c = cls, g = gotoksi, f = sinek, C = RENK

SDL'li C, 423 karakter

Orijinal sorun açıklaması SDL'den açıkça bahsettiğinden beri, SDL çözümünün sunulmasının geçmiş zaman olduğunu hissettim. Ne yazık ki, SDL işlevi ve yapılarının adları özellikle kısa değil, bu nedenle bu program biraz uzun. Aslında, dışarıda bırakamıyorum bile #include.

#include<math.h>
#include"SDL.h"
SDL_Surface*s;SDL_Event e;SDL_Rect p;int i,n;double q[256];main(){
SDL_Init(SDL_INIT_VIDEO);s=SDL_SetVideoMode(320,320,32,0);
for(srand(time(0));e.type-SDL_QUIT;n=-~n%64){
for(i=256*!n;i;q[--i]=rand()%65536*9.5874e-5);
for(SDL_FillRect(s,0,i=0);++i<256;SDL_FillRect(s,&p,-n*67372036))
p.x=160+cos(q[i])*q[i-1]*n,p.y=160+sin(q[i])*q[i-1]*n,p.w=p.h=1;
SDL_Flip(s);SDL_Delay(50);SDL_PollEvent(&e);}}

(Kod zaten çok büyük olduğundan, uyarılar olmadan derlenmesi için bazı ekstra bitler bıraktım. Bazen uyarılar olmadan derlemeyi özlüyorum. Bunları kaldırmak yaklaşık 30 veya daha fazla karakter kazandıracaktır.)

Animasyon sonsuz bir döngüde çalışır. Programdan çıkmak için pencereyi kapatın. Her patlamada yeni bir rastgele parçacık seti kullanılır.

Ayrıca 67372036koddaki numaraya işaret etmek istiyorum . İkinci çağrısındaki son bağımsız değişkenin ifadesinde görünür SDL_FillRect(). Kod olduğu gibi, patlama tamamen grilerde yapılır. Bu sayıyı biraz değiştirmek patlamaya çok ince ama hoş bir renk efekti katacaktır. Sayı 67372032, patlamanın başlangıcındaki parçacıkları renklendirirken, sayı 67372034, sonunda soluklaştıkça bir renk efekti sağlar. Diğer sayılar daha az ince renk döngüsü efektleri üretebilir. Onları denemenizi öneririm.

Buradaki diğer harika örneklerden bazılarını gördükten sonra, onu denemeye ve 140byt.es'e uyan bir parçacık işlevi yapmaya karar verdim.

Javascript, 282 karakter

( 138 karakter parçacık fonksiyonu ve 150 karakter temel tuval çizim kazan plakası)

p=function(a,t,x,y,n,g,s,i,d){with(Math)for(i=n;i--;d=cos(i*sin(i*s)),a.globalAlpha=n/t/i,a.fillRect(x+t*sin(i)*d, y+t*cos(i)*d+t*g,2,2));};d=document;a=d.body.appendChild(d.createElement('canvas')).getContext('2d');t=setInterval("a.clearRect(0,0,300,150);p(a,t++, 50,50,1e3,.2,1)")

Canlı JSFiddle örneği burada

Kodu tamamen prosedürel hale getirerek artık herhangi bir dizi veya nesne atama koduna ihtiyacım yok, boyutu çok azaltıyor. Prosedürel bir etki yaratmanın başka güzel yan etkileri de vardır.

Kod, Yerçekimi, Tohumlar, Parçacık Sayısı, vb.Ommitting ile daha küçük yapılabilir, ancak bu özellikleri kaldırmak için çok güzel olduğunu düşünüyorum;).

Özellikleri

• Konfigüre edilebilir X, Y patlama merkezi.
• Yapılandırılabilir parçacık sayısı
• Dikey yönde yerçekimi: Parçacıklarınızın düşmesini veya uçmasını sağlayın!
• Görülebilir, her tohumun kendi patlaması vardır ve bilgisayarlarda her seferinde tam olarak bu patlamayı gösterecektir.
• Yavaş hareket, Hızlı İleri ve patlamalar oynamak Etkinin oluşturulma yöntemine bağlı olarak geriye doğru mümkündür.
• Boyut: 138 bayt.

Ek açıklama eklenmiş bir sürüm için GitHub'da da kontrol edin .

PyGame'li Python, 240 karakter

Python'da zaten bir çözüm olduğunu fark ettim, ama bu sadece karakter bastığından, güzel bir animasyon çizen bir tane yapmanın faydalı olacağını düşündüm.

Ungolfed, ne ile başladım:

import math
import random
import pygame
pygame.init()

screen = pygame.display.set_mode((800, 800))
particles = [(random.gauss(0,.5), random.uniform(0,6.28318)) for i in range(2000)]

for i in range(399):
    screen.fill((255,255,255))
    for speed, angle in particles:
        distance = i * speed
        x = 400 + distance * math.cos(angle)
        y = 400 + distance * math.sin(angle)
        screen.set_at((int(x), int(y)), (0,0,0))
    pygame.display.flip()

Çok hackery sonra. Bazı karakterleri kaydetmek için tam ekran. Ses veya yazı tipi kullanmıyorum, bu yüzden init()gereksiz olduğunu düşünüyorum (benim için çalışıyor).

import math as m,random,pygame
d,x,g=pygame.display,range(999),random.gauss
s,e=d.set_mode(),[(g(0,.2),g(0,9))for i in x]
for i in x:
 d.flip(),s.fill([255]*3)
 for v,a in e:
        y=400+i*v*m.cos(a),400+i*v*m.sin(a)
        s.set_at(map(int,y),[0]*3)

Python - 327 karakter

İlgilenen şeyler:

• Karmaşık sayıyı 2B vektör olarak kullan
• (v * cos(a), v * sin(a)) olarak uygulandı v*e**(1j*a)
• 3D patlamaya benziyor.
• Yerçekimi.

.

import pygame as P,random as R,math
R=R.random
D=P.display
D.init()
W=800
S=D.set_mode((W,W))
T=P.time.Clock()
C=lambda v:map(int,(v.real,v.imag))
X=[(8+R())*math.cos(R()*1.57)*2.7**(1j*R()*6.28) for i in range(999)]
for t in range(250):
 D.flip();T.tick(30);S.fill(2**24-1)
 for v in X:S.set_at(C(v*t+.005j*t*t+W/2*(1+1j)),0)

dwitter 112

c.width^=0
t?o.push({X:1e3,Y:500,U:S(99*t),V:C(9*t)}):o=[]
o.map(a=>{a.X+=a.U,a.Y+=a.V,x.fillRect(a.X,a.Y,9,9)})

dwitter.net kodunu kopyalayarak / yapıştırarak deneyin