बॉयलर एल्गोरिथ्म को लागू करें

परिचय

Boids एल्गोरिथ्म एक समूह में आकस्मिक व्यवहार की एक अपेक्षाकृत सरल प्रदर्शन है। इसके तीन मुख्य नियम हैं, जैसा कि इसके निर्माता क्रेग रेनॉल्ड्स ने बताया है:

बुनियादी झुंड के मॉडल में तीन सरल स्टीयरिंग व्यवहार होते हैं, जो बताते हैं कि कैसे एक व्यक्ति ने अपने निकट झुंडों के पदों और वेगों के आधार पर युद्धाभ्यास किया:

पृथक्करण : स्थानीय झुंडों की भीड़ से बचने के लिए।

संरेखण : स्थानीय झुंड के औसत शीर्ष की ओर कदम।

सामंजस्य : स्थानीय झुंड के औसत स्थिति की ओर बढ़ने के लिए।

प्रत्येक दृश्य में पूरे दृश्य के ज्यामितीय विवरण तक सीधी पहुंच होती है, लेकिन फ्लॉकिंग के लिए यह आवश्यक है कि वह केवल एक निश्चित छोटे पड़ोस के भीतर ही झुंड में प्रतिक्रिया करे। पड़ोस की दूरी (बोद के केंद्र से मापी गई) और कोण की विशेषता है , जिसे उड़ान की उड़ान की दिशा से मापा जाता है। इस स्थानीय पड़ोस के बाहर के झुंडों को अनदेखा किया जाता है। पड़ोस को सीमित धारणा का मॉडल माना जा सकता है (जैसा कि पानी में मछली द्वारा होता है) लेकिन यह शायद इस क्षेत्र को परिभाषित करने के रूप में अधिक सही है, जिसमें झुंड के साथी एक बॉयलर स्टीयरिंग को प्रभावित करते हैं।

मैं चीजों की व्याख्या करते समय सही नहीं हूं, इसलिए मैं स्रोत की जांच करने की अत्यधिक सलाह देता हूं । उनकी साइट पर कुछ सुपर जानकारीपूर्ण तस्वीरें भी हैं।

चुनौती

Boids की संख्या (सिम्युलेटेड इकाइयां) और फ़्रेम की संख्या को देखते हुए, सिमुलेशन का एक एनीमेशन आउटपुट।

Boids को एक लाल वृत्त के रूप में प्रस्तुत किया जाना चाहिए, सर्कल के अंदर एक पंक्ति अपनी हेडिंग दिखाती है, यह वह दिशा है जो boid इंगित करता है:

प्रत्येक फोड़े का कोण (जैसा कि रेनॉल्ड्स द्वारा वर्णित है) एक पूर्ण 300 डिग्री होना चाहिए। (360 नहीं)
प्रत्येक फोड़े की शुरुआती हेडिंग और पोजिशन समान रूप से रैंडम होनी चाहिए (लेकिन सीडेड, ताकि आउटपुट अभी भी निर्धारित हो), साथ ही पोजिशन भी।
अगर फोड़े की त्रिज्या 1 है, तो पड़ोस की त्रिज्या 3 होनी चाहिए।
Boids की संख्या 2-20 से कहीं भी होगी।
फ्रेम की संख्या 1-5000 से कहीं भी होगी
एनीमेशन को न्यूनतम 10 मिलीसेकंड प्रति फ्रेम और अधिकतम 1 सेकंड की संख्या के साथ खेला जाना चाहिए। (2 boids = 2 सेकंड प्रति फ्रेम अधिकतम, 3 boids = 3 सेकंड प्रति फ्रेम अधिकतम, et cetera)
आउटपुट एनीमेशन कम से कम 5 बोइड-रेडी 5 बोइड-रेडी से होना चाहिए, बड्स की आधी संख्या। तो, 2 बोलियों के लिए न्यूनतम आकार 10 बोरी-राडाइयॉइड 10 बोइड-रेडी, 3 बोयड के लिए न्यूनतम 15 बोइड-रेडी 15 बोटी-रेडी, एट सीटेरा होगा।
प्रत्येक फोड़े की त्रिज्या न्यूनतम 5 पिक्सेल और अधिकतम 50 पिक्सेल होनी चाहिए।
प्रत्येक फोड़े की गति को सीमित करने की आवश्यकता है ताकि यह एक दायरे में अपने दायरे के 1/5 वें से अधिक न चले।
आउटपुट को निर्धारित करने की आवश्यकता है, ताकि एक ही इनपुट कई बार चलाने पर एक ही आउटपुट का उत्पादन कर सके।
यदि एक सीमा पर एक फोड़ा पहुंचता है, तो उसे वापस दूसरी तरफ लपेटना चाहिए। इसी तरह, प्रत्येक फोड़े के आस-पास के पड़ोस को भी सीमाओं के आसपास लपेटना चाहिए।

एल्गोरिथ्म के नियम

इस मामले में, प्रत्येक प्रकोष्ठ के चारों ओर एक क्षेत्र होता है, जो 300 डिग्री तक फैला होता है, जो कि व्रत के शीर्ष पर केंद्रित होता है। इस "पड़ोस" में किसी भी अन्य boids को "पड़ोसी" माना जाता है, या (रेनॉल्ड्स शब्द का उपयोग करने के लिए) "फ्लॉकमेट्स"।

प्रत्येक बोइड को टकराव से बचने और अपने पड़ोसियों के साथ एक बायिड-रेडियस की आरामदायक दूरी बनाए रखने के लिए इसकी हेडिंग को समायोजित करना चाहिए। (यह एल्गोरिथ्म का "पृथक्करण" पहलू है। एक बोइद-त्रिज्या को बाईपास किया जा सकता है, लेकिन यह रबर बैंड की तरह होना चाहिए, वापस जगह में तड़कना।)
जब तक यह पहले नियम के साथ हस्तक्षेप नहीं करता है, तब तक प्रत्येक बोद को इसके हेडिंग को अन्य बॉड्स की औसत हेडिंग के करीब होने के लिए समायोजित करना चाहिए। (यह एल्गोरिथम का "संरेखण" पहलू है)
जब तक यह टकराव का कारण नहीं बनता है या दूसरे नियम में काफी हस्तक्षेप नहीं करता है, तब तक प्रत्येक फोड़े को अपने झुंड के औसत स्थान की ओर मुड़ना चाहिए।

में इस विषय पर अपने कागज , वह यह बताता है इस प्रकार है:

एक नकली झुंड बनाने के लिए, हम एक मॉडल के साथ शुरू करते हैं जो ज्यामितीय उड़ान का समर्थन करता है। हम उन व्यवहारों को जोड़ते हैं जो टकराव से बचने के विरोधी ताकतों के साथ मेल खाते हैं और झुंड में शामिल होने का आग्रह करते हैं। नियमों के अनुसार संक्षिप्त रूप में, और पूर्ववर्तीता घटने के क्रम में, व्यवहार जो नकली झुंझलाहट की ओर ले जाते हैं:

टकराव से बचाव: निकटवर्ती फ्लॉकमेट्स के साथ टकराव से बचें

वेग मिलान: पास के झुंड के साथ वेग का मिलान करने का प्रयास

फ्लॉक सेंट्रिंग: पास के फ्लॉकमेट्स के करीब रहने का प्रयास

आंदोलन का अधिक विस्तृत विवरण:

Boids Algorithm का मानक कार्यान्वयन आमतौर पर प्रत्येक नियम के लिए एक गणना करता है, और इसे एक साथ विलय करता है।
पहले नियम के लिए, फोड़ा अपने पड़ोस के भीतर पड़ोसी की सूची के माध्यम से जाता है, और यदि स्वयं और पड़ोसी के बीच की दूरी एक निश्चित मूल्य से कम है, तो एक वेक्टर जो पड़ोसी को दूर धकेलता है, उसे बॉयलर की हेडिंग पर लागू किया जाता है।
दूसरे नियम के लिए, Boid अपने पड़ोसियों की औसत हेडिंग की गणना करता है, और उसके वर्तमान हेडिंग और उसके वर्तमान हेडिंग के औसत हेडिंग के बीच अंतर का एक छोटा सा हिस्सा (हम इस चुनौती में 1/10 का उपयोग करेंगे) जोड़ते हैं।
तीसरे और अंतिम नियम के लिए, Boid अपने पड़ोसियों की स्थिति को औसत करता है, एक वेक्टर की गणना करता है जो इस स्थान की ओर इशारा करता है। इस वेक्टर को नियम 2 (इस चुनौती के लिए, 1/50 का उपयोग किया जाएगा) की तुलना में एक छोटी संख्या से गुणा किया जाता है और शीर्षक पर लागू किया जाता है।
फिर फोड़े को उसके शीर्ष की दिशा में ले जाया जाता है

यहाँ Boids Algorithm का एक उपयोगी छद्मकोड कार्यान्वयन है।

उदाहरण इनपुट और आउटपुट

इनपुट:

5, 190 (5 बोलियां, 190 फ्रेम)

आउटपुट:

कसौटी जीतना

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा समाधान जीतता है।

— iPhoenix
स्रोत

"निश्चित रूप से, एल्गोरिथ्म के लिए अधिक है, इसलिए मैं स्रोत की जांच करने की अत्यधिक सलाह देता हूं।" - यहां सब कुछ जरूरी है या नहीं? अगर नहीं तो मैं उसे ठीक करने की सलाह दूंगा।

— जोनाथन एलन

चुनौतियों को पोस्ट करने से पहले सैंडबॉक्स का उपयोग करें , जैसा कि पूछें पृष्ठ पर दिया गया है ।

— त्रुटिपूर्ण

@JonathanAllan हाँ, यहाँ आवश्यक सब कुछ है, लेकिन अधिक गहराई से व्याख्या जो अन्य उपयोगकर्ताओं को अधिक समझ में आ सकती है, स्रोत पर उपलब्ध हैं।

— iPhoenix

यह एक दिलचस्प चुनौती है (मुझे आकर्षक व्यवहार आकर्षक लगते हैं) लेकिन इसे अच्छी तरह से निर्दिष्ट करने की आवश्यकता होगी, विशेष रूप से एक कोड-गोल्फ के लिए, अन्यथा कोड की लंबाई को कम करने का दबाव चुनौती की भावना से हर संभव विचलन का कारण होगा। प्रोत्साहित किया जाए।

— त्रिकोप्लक्स

जवाबों:

प्रसंस्करण 3.3.6 (जावा) ,932 931 940 928 957 917 904 बाइट्स

^{-1 से बाइट जोनाथन frech

बेहतर करने के लिए +11 बाइट्स से मेल कल्पना

-2 से बाइट्स केविन Cruijssen

टी करने के लिए आर्ग () को बदलने के लिए -12 बाइट्स

+29 बाइट्स क्योंकि मैं गलत ghosting कर रहा था, नीचे संस्करण टिप्पणी की देख

के लिए उपयोग करने के लिए -40 बाइट्स

डिफ़ॉल्ट फ्रेम का उपयोग करने के लिए प्रत्येक भूत -13 बाइट्स के लिए अलग-अलग कॉल के बजाय छोरों , 30}

खैर, यह एक शुरुआत है, किसी के लिए जो जावा-गोल्फ नहीं करता है। :)

int n=15,f=400,i,j,z=255,w=500;float d=200./n;PVector m;B[]a=new B[n];void setup(){size(500,500);fill(z,0,0);randomSeed(n);for(i=0;i<n;a[i++]=new B(new PVector(random(w),random(w)),m.fromAngle(random(TAU))));}void draw(){background(z);for(B b:a)b.u();if(frameCount%f<1)setup();}class B{PVector p,v,e,q,r;ArrayList<B>n;B(PVector m,PVector o){p=m;v=o;}void u(){e=v.copy();n=new ArrayList();for(B b:a){if(b!=this)for(i=-w;i<=w;i+=w)for(j=-w;j<=w;j+=w)t(i,j,b);}if(n.size()>0){q=new PVector();r=q.copy();for(B b:n){q.add(b.v);r.add(b.p);if(p.dist(b.p)<=d)e.add(p).sub(b.p);}e.add(q.div(n.size()).sub(v).div(10));e.add(r.div(n.size()).sub(p).div(50));}p.add(e.limit(d/10));v=e.mult(10);p.set((p.x+w)%w,(p.y+w)%w);noStroke();ellipse(p.x,p.y,d,d);stroke(0,0,z);line(p.x,p.y,p.x+v.x,p.y+v.y);}void t(int x,int y,B o){m=o.p.copy().add(x,y);if(2*d>=p.dist(m)&q.angleBetween(v,q.sub(m,p))<=5*PI/6)n.add(new B(m,o.v));}}

मुझे प्रसंस्करण में इनपुट करने का कोई उचित तरीका नहीं पता है, इसलिए पहले दो चर इनपुट हैं (और मैंने बाइट गिनती की ओर उनके मूल्यों (5 बाइट्स) की गणना नहीं की)। यदि यह एक समस्या है, तो मैं अन्य चीजों की कोशिश कर सकता हूं।

मुझे खुद को आज़माने की अनुमति देने का एक अच्छा तरीका भी नहीं पता है (प्रोसेसिंग.जेएस प्रोजेक्ट इस कोड शैली से निपट नहीं सकता है) चीजों को स्वयं होस्ट किए बिना; और वह कुछ ऐसा है जिसे मैं प्रयास करने के लिए उत्सुक नहीं हूं। मुझे पता है कि अगर कुछ होशियार है तो मैं कर सकता हूं।

टिप्पणी के साथ प्रारूपित कोड

int n=15, // Number of boids
    f=400, // Number of frames
    i,j,z=255,w=500; // temp*2, and two constants
float d=200./n; // Boid diameter
PVector m; // temp
B[]a=new B[n];
void setup(){ // This is automatically called at startup
  size(500,500); // Can't use variables for this without extra bytes for settings()
  fill(z,0,0);
  randomSeed(n); // seeded from number of Boids, so that n=19 is very different from n=20
  for(i=0;i<n;a[i++]=new B(new PVector(random(w),random(w)),m.fromAngle(random(TAU))));
}
void draw(){ // This is automatically called each frame
  background(z);
  for(B b:a)
    b.u();
  if(frameCount%f<1) // When desired frames length is hit, reset everything.
    setup();         // Could also use noLoop() instead of setup() to just stop instead.
                     // Or, remove this if statement altogether to go on to infinity.
}
class B{ // Boid
  PVector p,v,e,q,r; // Position, Velocity, Next velocity, and two temp vectors
  ArrayList<B>n; // List of neighbors
  B(PVector m,PVector o){
    p=m;
    v=o;
  }
  void u(){ // Update function, does rules and redraw for this Boid
    e=v.copy();
    n=new ArrayList();
    for(B b:a){ // Test a Boid and its eight ghosts for neighborship
      if(b!=this) // Note: Assumes neighborhood diameter < min(width,height)
        // The ghosts are to check if it'd be closer to measure by wrapping
        // We need eight for wrapping north, east, south, west, northeast,
        // northwest, southeast, and southwest. And also the non-wrapped one.
        // The above assumption ensures that each ghost is further apart than
        // the neighborhood diameter, meaning that only one neighbor might be
        // found for each boid. To test this, place a boid in each corner, right
        // to the edge, facing away from center. Each boid should find three
        // neighbors, that are the three other boids.
        for(i=-w;i<=w;i+=w)for(j=-w;j<=w;j+=w)t(i,j,b);
    }
    if(n.size()>0){
      q=new PVector();
      r=q.copy();
      for(B b:n){
        q.add(b.v); // Velocity matching, pt 1
        r.add(b.p); // Flock centering, pt 1
        if(p.dist(b.p)<=d)  
          e.add(p).sub(b.p); // Collision avoidance
      }
      e.add(q.div(n.size()).sub(v).div(10)); // Velocity matching, pt 2
      e.add(r.div(n.size()).sub(p).div(50)); // Flock centering, pt 2
    }
    p.add(e.limit(d/10)); // Update vectors
    v=e.mult(10);
    p.set((p.x+w)%w,(p.y+w)%w); // Wrapping
    noStroke();
    ellipse(p.x,p.y,d,d); // Draw Boid, finally
    stroke(0,0,z);
    line(p.x,p.y,p.x+v.x,p.y+v.y);
  }
  void t(int x,int y,B o){ // Test if a Boid (or a ghost) is a neighbor
    m=o.p.copy().add(x,y);
    if(2*d>=p.dist(m)&q.angleBetween(v,q.sub(m,p))<=5*PI/6)
      n.add(new B(m,o.v));
  }
}

नमूना उत्पादन

n = 15, फ्रेम = 400:

या, एक ही एनीमेशन, लेकिन प्रत्येक फोड़े का पड़ोस दिखा।

— Phlarx
स्रोत

क्या एक बाइट को बचाने के लिए 2*PIनहीं बन सकता है TAU?

— जोनाथन फ्रीच

@ जोनाथनफ्रेच हां यह कर सकता है; मेरे पास मूल रूप से -PI, PI था और मैं इस तरह से जा रहा था, लेकिन अलग हो गया।

— फेल्क्स

मेरा कार्यक्रम (जो js और html में लिखा गया था) एक gif निर्यात नहीं करता था, लेकिन इसने एक छवि को आकर्षित किया और मैंने एक स्क्रीन कैप्चरिंग प्रोग्राम का उपयोग किया और वीडियो को इसे gif में निर्यात किया। एक बात है जो मैंने नोटिस की थी, हालांकि। Boids में एक नीली रूपरेखा होती है, जो कल्पना का अनुसरण नहीं करती है :)

— iPhoenix

बस एक और अनुकूल अनुस्मारक, यह जवाब कल्पना का पालन नहीं करता है, इसलिए यह इनाम नहीं मिलेगा।

— iPhoenix

मैं प्रसंस्करण पता नहीं है, लेकिन मुझे लगता है आप गोल्फ निम्नलिखित बातें कर सकते हैं: ,i,करने के लिए ,i=0,और उसके बाद हटाने i=0के लिए लूप के अंदर। (-1 बाइट); frameCount%f==0, frameCount%f<1(1 बाइट); &&करने के लिए &अंतिम अगर में 2*d>=p.dist(m)&q.angleBetween(v,q.sub(m,p))<=5*PI/6(-1 बाइट)। फिर से, सुनिश्चित नहीं हैं कि ये संभव हैं, लेकिन चूंकि प्रसंस्करण जावा के समान प्रतीत होता है, मुझे लगता है कि यह है। इसके अलावा, आप screentogif.com के साथ gif बनाने का प्रयास कर सकते हैं ।

— केविन क्रूज़सेन

जावास्क्रिप्ट (ईएस 6) + एचटीएमएल 5, 1200 बाइट्स

यहाँ मेरा वर्तमान समाधान कैनवस एपीआई का उपयोग कर रहा है। eval()एक curried समारोह जिनकी पहली इनपुट है रिटर्न Boidआबादी, और दूसरा एनीमेशन फ्रेम की संख्या है। आप उपयोग कर सकते हैंInfinity निरंतर एनीमेशन के लिए ।

eval(...)1187 बाइट्स और <canvas id=c>13 बाइट्स की है, 1200 की कुल सीएसएस अनावश्यक है बना रही है, लेकिन सुविधा के लिए, यह आप कैनवास के किनारों को देखने के लिए अनुमति देता है।

eval("L7F7{function B8{t=this,t.a=o8*T,t.x=o8*S,t.y=o8*S}C=this.c,D=C.getContext`2d`,({abs:z,random:o,atan2:k,cos:u,sin:g,PI:P,T=2*P,G={c:_7A[r='filter'](b7b!=t)[i](9)79)),n:_7A[r](b7b!=t)[i](9)7({a,x,y:y-S})),s:_7A[r](b7b!=t)[i](9)7({a,x,y:y+S})),e:_7A[r](b7b!=t)[i](9)7({a,x:x-S,y})),w:_7A[r](b7b!=t)[i](9)7({a,x:x+S,y}))},M=I7[I,I+T,I-T][p]((a,x)7z(x)<z(a)?x:a)}=Math),B.prototype={d8{with(D)save8,translate(x,y),rotate(a),beginPath8,arc(0,0,5,0,T),fillStyle='red',fill8,beginPath8,moveTo(0,0),lineTo(10,0),strokeStyle='blue',stroke8,restore8},n:_7(({c,n,s,e,w}=G),c8.concat(n8,s8,e8,w8)[r](b7(d=b.x-x,f=b.y-y,400>d*d+f*f&&z(z(k(f,d)-a)/P-1)>1/6))),s8{q=(j=t.n8).length,v=t.v8||0,l=t.l8||0,f=t.f8||0,a=t.a=(t.a+v+l/10+f/50)%T,t.x=(x+u(a)+S)%S,t.y=(y+g(a)+S)%S},v:_7([d,f]=j[r](b7225>(b.x-x)**2+(b.y-y)**2)[p='reduce'](([d,f],b)7[x+d-b.x,y+f-b.y],[0,0]),d||f?M(k(f,d)-a):0),l:_7j[i](b7M(b.a-a))[p]((a,x)7a+x,0)/q,f:_7([d,f]=j[p](([d,f],b)7[d+b.x,f+b.y],[-x*q,-y*q]),d||f?M(k(f,d)-a):0)},S=C.width=C.height=50*L,A=Array(L).fill().map(_7new B),R=_7{D.clearRect(0,0,S,S),A[i='map'](b79=b).d8),A[i](b79=t=b).s8),F--&&setTimeout(R,10)},R8}".replace(/[789]/g,m=>['=>','()','({a,x,y}'][m-7]))
(10)(Infinity)

canvas{border:1px solid}

<canvas id=c>

स्निपेट का विस्तार करें

संपादित करें

अनुरोध के अनुसार, Boid जनसंख्या के लिए इनपुट के साथ एक और स्निपेट:

b.onchange=()=>{eval("L7F7{function B8{t=this,t.a=o8*T,t.x=o8*S,t.y=o8*S}C=this.c,D=C.getContext`2d`,({abs:z,random:o,atan2:k,cos:u,sin:g,PI:P,T=2*P,G={c:_7A[r='filter'](b7b!=t)[i](9)79)),n:_7A[r](b7b!=t)[i](9)7({a,x,y:y-S})),s:_7A[r](b7b!=t)[i](9)7({a,x,y:y+S})),e:_7A[r](b7b!=t)[i](9)7({a,x:x-S,y})),w:_7A[r](b7b!=t)[i](9)7({a,x:x+S,y}))},M=I7[I,I+T,I-T][p]((a,x)7z(x)<z(a)?x:a)}=Math),B.prototype={d8{with(D)save8,translate(x,y),rotate(a),beginPath8,arc(0,0,5,0,T),fillStyle='red',fill8,beginPath8,moveTo(0,0),lineTo(10,0),strokeStyle='blue',stroke8,restore8},n:_7(({c,n,s,e,w}=G),c8.concat(n8,s8,e8,w8)[r](b7(d=b.x-x,f=b.y-y,400>d*d+f*f&&z(z(k(f,d)-a)/P-1)>1/6))),s8{q=(j=t.n8).length,v=t.v8||0,l=t.l8||0,f=t.f8||0,a=t.a=(t.a+v/3+l/10+f/50)%T,t.x=(x+u(a)+S)%S,t.y=(y+g(a)+S)%S},v:_7([d,f]=j[r](b7225>(b.x-x)**2+(b.y-y)**2)[p='reduce'](([d,f],b)7[x+d-b.x,y+f-b.y],[0,0]),d||f?M(k(f,d)-a):0),l:_7j[i](b7M(b.a-a))[p]((a,x)7a+x,0)/q,f:_7([d,f]=j[p](([d,f],b)7[d+b.x,f+b.y],[-x*q,-y*q]),d||f?M(k(f,d)-a):0)},S=C.width=C.height=50*L,A=Array(L).fill().map(_7new B),R=_7{D.clearRect(0,0,S,S),A[i='map'](b79=b).d8),A[i](b79=t=b).s8),F--&&setTimeout(R,10)},R8}".replace(/[789]/g,m=>['=>','()','({a,x,y}'][m-7]))(+b.value)(Infinity);b.remove()}

input{display:block}canvas{border:1px solid}

<input id=b><canvas id=c>

स्निपेट का विस्तार करें

— पैट्रिक रॉबर्ट्स
स्रोत

जब मैं स्निपेट चलाता हूं, तो बोयड इंटरेक्ट नहीं लगता

— जो किंग

@ जोक अब इसे ठीक किया जाना चाहिए

— पैट्रिक रॉबर्ट्स

समस्या इसलिए थी क्योंकि बैबल मिनिफायर एक पैरामीटर नाम के साथ एक फ़ंक्शन में एक वैश्विक चर को छायांकित करता था, और एक नंबर को निहित टाइपकास्ट में कोई त्रुटि नहीं थी, इसलिए फ़ंक्शन चुपचाप विफल हो गया और कभी भी किसी भी पड़ोसी का पता नहीं लगा।

— पैट्रिक रॉबर्ट्स

मैं कल रात एक इंटरैक्टिव डेमो बनाने की कोशिश करूँगा, लेकिन मैं आज रात भाप से बाहर चला गया हूं।

— पैट्रिक रॉबर्ट्स

बस एक नोट: जहां यह पढ़ता है t.a+v+l/10+f/50, अगर आप इसे बदलते हैं, तो t.a+v/3+l/10+f/50यह कुछ और दिलचस्प व्यवहार पैदा करता है, लेकिन वर्तमान कार्यक्रम छोटा है और अभी भी कल्पना करना है।

— पैट्रिक रॉबर्ट्स