Dapatkah Anda menulis sebuah program yang menampilkan sekelompok piksel yang meledak terpisah (seperti pada mesin partikel sederhana) dan dapatkah Anda melakukan ini dalam sejumlah kecil karakter (penekanan tombol)? (Ingat lemming permainan, ketika orang-orang kecil itu akan meledak dan potongan-potongan piksel kecil mereka terbang terpisah.)

Seseorang memprogram sistem partikel sederhana di sini sebagai sketsa Pemrosesan dan cukup lumayan dibandingkan dengan apa yang saya pikir orang lain dapat capai jika mereka mencobanya. Tetapi saya akan jauh lebih terkesan jika seseorang dapat melakukan hal yang sama di c ++ dan sdl, atau bahkan java atau c #.

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

Tidak terlalu serius; ini terutama merupakan upaya apakah itu benar-benar berhasil.

Apa yang saya lakukan di sini adalah menggunakan ItemsControl (Menu, karena lebih pendek) di WPF untuk menampilkan partikel melalui pengikatan dan templating data. Templat data mengontrol bagaimana bentuk partikel (dalam hal ini lingkaran sederhana) dan pengikatan data mengontrol warna dan posisi partikel.

Setiap partikel memiliki posisi, warna dan arah yang dapat diperbarui oleh pengatur waktu. Awalnya sekelompok partikel dihasilkan di tengah jendela dengan arah acak (terdistribusi normal). Koleksi itu mendapat data-terikat ke ItemsControl yang kemudian menangani menampilkan partikel secara otomatis, setiap kali properti diperbarui. Partikel terseret sedikit karena gravitasi.

Memang agak panjang, harus diakui. Tapi setidaknya itu terlihat bagus:

Itu pasti bisa dibuat lebih pendek dengan menghilangkan:

• gravitasi, menyebabkan partikel mengembang secara seragam ke semua sisi;
• distribusi normal untuk vektor awal, menyebabkan partikel mengembang dalam kotak »yang jarang;
• variasi kecerahan, meninggalkan partikel hitam.

Saya memilih untuk tidak melakukannya demi kepentingan estetika. Solusi ini jauh lebih lama daripada hampir semua hal lainnya. Pendekatan data-binding dan templating mungkin elegan tetapi juga sangat bertele-tele dibandingkan dengan hanya memperbarui bitmap. (Catatan: Saya turun ke 1356 dengan membiarkan semua hal di atas keluar, tapi itu terlihat mengerikan kemudian.)

Kode didistribusikan dalam tiga file, yang diberikan di sini dalam bentuk yang diformat untuk keterbacaan:

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

catatan tambahan - 287 244 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

jalankan bersama gs -dNOPAUSE asplode.ps

Anda bahkan bisa mencetaknya dan membuat flipbook

Javascript - 268 karakter

Inilah ledakan 1 dimensi, 2 partikel,:

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)

Untuk menjalankannya, buka halaman about: blank di browser web yang bagus, rekatkan ke bilah url dan tekan enter. Anda dapat memodifikasi ledakan dengan mengedit nilai di bagian akhir s(10,5,1,0). Nilai pertama adalah ukuran partikel yang meledak. Nilai kedua adalah ukuran partikel yang meledak keluar darinya. Nilai ketiga adalah kecepatan partikel yang meledak darinya. Biarkan '0' apa adanya.

APL ( 120 118)

Ini memiliki jenis output yang sama dengan entri Python (yaitu hanya menampilkan status pada kotak karakter). Hanya kisi-kisi 30x15 dan asal partikel pada 15x7.

⍎⊃,⌿(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

Ini adalah kombinasi dari jawaban Joey dan david4dev (ini adalah salinan tak tahu malu dari algoritma Joey yang diimplementasikan menggunakan Javascript / kanvas ☺):

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)

Pratinjau JSFiddle: http://jsfiddle.net/GVqFr/60/ (Anda dapat menekan tombol TidyUp untuk memformat kode dengan baik)

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
}

Sebut e like explode.

pembaruan: berwarna

t = teks, c = cls, g = gotoxy, f = fly, C = COLOR

C dengan SDL, 423 karakter

Karena deskripsi masalah asli secara eksplisit menyebutkan SDL, saya merasa sudah lewat masa solusi SDL diajukan. Sayangnya, nama-nama fungsi dan struct SDL tidak terlalu singkat, jadi program ini agak panjang. Bahkan, saya bahkan tidak bisa meninggalkan #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);}}

(Karena kodenya sudah sangat besar, saya meninggalkan beberapa bit tambahan sehingga akan dikompilasi tanpa peringatan. Kadang-kadang saya ketinggalan kompilasi tanpa peringatan. Menghapusnya akan menghemat sekitar 30 atau lebih karakter.)

Animasi berjalan dalam loop yang tak terbatas. Tutup jendela untuk keluar dari program. Setiap ledakan menggunakan set partikel acak baru.

Saya juga ingin menunjukkan nomor 67372036dalam kode. Itu muncul dalam ekspresi untuk argumen terakhir dalam panggilan kedua ke SDL_FillRect(). Sebagai kode berdiri, ledakan itu sepenuhnya menjadi abu-abu. Mengubah nomor ini sedikit akan menambah efek warna yang sangat halus tapi menyenangkan untuk ledakan. Nomor 67372032warna partikel pada awal ledakan, sedangkan nomor 67372034memberikan efek warna saat mereka memudar pada akhirnya. Nomor lain dapat menghasilkan efek siklus warna yang lebih halus. Saya mendorong Anda untuk mencobanya.

Setelah melihat beberapa contoh hebat lainnya di sini, saya memutuskan untuk mencobanya, dan membuat fungsi partikel yang sesuai dengan 140byt.es

Javascript, 282 karakter

( 138 karakter chars fungsi dan 150 karakter dasar kanvas menggambar boilerplate)

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

Contoh langsung JSFiddle di sini

Dengan membuat kode sepenuhnya prosedural saya tidak lagi membutuhkan kode array atau objek-tugas, mengurangi ukuran banyak. Membuat efek prosedural juga memiliki beberapa efek samping yang bagus.

Kode dapat dibuat lebih kecil dengan menonaktifkan Gravity, Seeds, Number of Particles, dll, tapi saya pikir fitur ini terlalu bagus untuk dihapus;).

fitur

• Configurable X, Y pusat ledakan.
• Jumlah partikel yang dapat dikonfigurasi
• Gravitasi ke arah vertikal: Biarkan partikel Anda jatuh atau terbang!
• Diunggulkan, setiap biji memiliki ledakannya sendiri dan akan menunjukkan dengan tepat ledakan itu setiap kali, di seluruh komputer.
• Slowmotion, Maju Cepat dan memainkan ledakan Mundur adalah mungkin, karena cara prosedural efeknya dibuat.
• Ukuran: 138 byte.

Periksa juga di GitHub , untuk versi yang beranotasi.

Python dengan PyGame, 240 karakter

Saya menyadari bahwa sudah ada solusi dalam python, tetapi karena yang hanya mencetak karakter, saya pikir akan bermanfaat untuk membuat satu yang menarik animasi yang bagus.

Tidak disatukan, apa yang saya mulai dengan:

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

Setelah banyak peretasan. Layar penuh untuk menyimpan beberapa karakter. Tidak menggunakan suara atau font, jadi saya pikir init()tidak perlu (ini berfungsi untuk saya).

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

Hal-hal menarik:

• Gunakan bilangan kompleks sebagai vektor 2D
• (v * cos(a), v * sin(a)) diimplementasikan sebagai v*e**(1j*a)
• Tampak seperti ledakan 3D.
• Gravitasi.

.

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

coba dengan menyalin / menempel kode ke dwitter.net