बारिश सिम्युलेटिंग

Question

मैं जावा में एक गेम बना रहा हूं और मैं बारिश डालने वाले बादल का सिमुलेशन बनाना चाहता हूं। बारिश के दौरान बादल को दाईं ओर जाना चाहिए। बादल को स्थानांतरित करना कोई समस्या नहीं है। यह बारिश है जिसके साथ मैं संघर्ष कर रहा हूं।

जो मैं सोच रहा था वह आयताकार बनाने के लिए एक टाइमर के साथ था, जो क्लाउड के अंदर एक यादृच्छिक एक्स मान पर बारिश की तरह लग रहा था। और फिर प्रत्येक 100 मिलीसेकंद ड्रॉप के वाई मान में 1 जोड़ें। लेकिन मैं प्रत्येक बारिश ड्रॉप के लिए 100 अलग आयताकार, एक्स चर और वाई चर बनाना नहीं चाहता हूं।

कोई विचार यह है कि मैं इसे कैसे पूरा कर सकता हूं? सुझावों की सराहना की!

---

यह एक 2 डी गेम है .. क्षमा करें।

Answer 1

मैं केवल ऑब्जेक्ट्स के ऐरेलिस्ट के रूप में मानों को संग्रहीत करने की अनुशंसा करता हूं।

class Raindrop { 
    private int x; 
    private int y; 

    public void fall() { 
     y--; 
    } 
} 

फिर एक सामान्य प्रकार के साथ एक ऐरेलिस्ट बनाएं।

ArrayList<Raindrop> drops = new ArrayList<Raindrop>(); 

प्रत्येक ड्रॉप गिरावट बनाने के लिए,

for (int i=0; i<drops.length(); i++) { 
    drops.get(i).fall(); 
} 

Answer 2

एक दृष्टिकोण थियेटर पर एक मार्की पर विचार करना होगा। आप बल्बों की एक श्रृंखला लेते हैं और अनुक्रम में प्रकाश और बुझाने से, आप रैखिक गति अनुकरण कर सकते हैं।

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

Answer 3

आप एक कण प्रणाली का उपयोग कर सकते हैं या raindrops के वेक्टर का उपयोग कर सकते हैं और उन्हें प्रत्येक एक्स मिलीसेकंड एनिमेट कर सकते हैं। एक कण प्रणाली पुस्तकालय का एक लिंक: वेक्टर के लिए http://code.google.com/p/jops/

उदाहरण कोड:

import java.util.Vector; 
// In your class 
Vector raindrops; 
void animate() 
{ 
    ListIterator iter = raindrops.listIterator; 
    while (iter.hasNext()) { 
     ((Raindrop)iter.next()).moveDown(); 
    } 
} 

Answer 4

यह एक आवश्यकता है कि बारिश की बूंदों से प्रोग्राम किया जा है? परंपरागत रूप से, यह कुछ बारिश sprites के साथ किया जाएगा जो आप बादल के नीचे रखें और एनिमेट करें ताकि ऐसा लगता है कि बारिश गिर रही है।

Answer 5

यहाँ मेरी जावा (स्विंग) बूंदें, छप, हवा और गुरुत्वाकर्षण

import java.awt.BasicStroke; 
import java.awt.Color; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.event.WindowAdapter; 
import java.awt.event.WindowEvent; 
import java.awt.geom.Ellipse2D; 
import java.awt.geom.Line2D; 
import java.util.ArrayList; 
import java.util.Iterator; 
import java.util.Random; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 

public class Main { 

public static void main(String [] args) { 
    JFrame frame = new JFrame(); 
    frame.setSize(800, 300); 
    final RPanel rPanel=new RPanel(); 
    frame.add(rPanel); 
    frame.setVisible(true); 
    frame.addWindowListener(new WindowAdapter() { 
     @Override 
     public void windowClosing(WindowEvent e) { 
      super.windowClosing(e); 
      rPanel.stop(); 
      System.exit(0); 
     } 
    }); 
} 
} 

class RPanel extends JPanel { 
//*********SETTINGS**************************** 
private float mWind = 2.05f; 
private float mGravity = 9.8f; 
private double mRainChance = 0.99; // from 0 to 1 

private int mRepaintTimeMS = 16; 
private float mRainWidth=1; 
private double mDdropInitialVelocity = 20; 
private double mDropDiam = 2; 
private Color mColor=new Color(0, 0, 255); 
//********************************************* 

private ArrayList<Rain> rainV; 
private ArrayList<Drop> dropV; 
private UpdateThread mUpdateThread; 

public RPanel() { 
    rainV = new ArrayList<>(); 
    dropV = new ArrayList<>(); 

    mUpdateThread=new UpdateThread(); 
    mUpdateThread.start(); 
} 

public void stop() { 
    mUpdateThread.stopped=true; 
} 

public int getHeight() { 
    return this.getSize().height; 
} 

public int getWidth() { 
    return this.getSize().width; 
} 

private class UpdateThread extends Thread { 
    public volatile boolean stopped=false; 
    @Override 
    public void run() { 
     while (!stopped) { 
      RPanel.this.repaint(); 
      try { 
       Thread.sleep(mRepaintTimeMS); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 
     } 
    } 
} 

@Override 
public void paintComponent(Graphics g) { 
    super.paintComponent(g); 
    Graphics2D g2 = (Graphics2D) g; 
    g2.setStroke(new BasicStroke(mRainWidth)); 
    g2.setColor(mColor); 

    //DRAW DROPS 
    Iterator<Drop> iterator2 = dropV.iterator(); 
    while (iterator2.hasNext()) { 
     Drop drop = iterator2.next(); 
     drop.update(); 
     drop.draw(g2); 

     if (drop.y >= getHeight()) { 
      iterator2.remove(); 
     } 
    } 

    //DRAW RAIN 
    Iterator<Rain> iterator = rainV.iterator(); 
    while (iterator.hasNext()) { 
     Rain rain = iterator.next(); 
     rain.update(); 
     rain.draw(g2); 

     if (rain.y >= getHeight()) { 
      //create new drops (2-8) 
      long dropCount = 1 + Math.round(Math.random() * 4); 
      for (int i = 0; i < dropCount; i++) { 
       dropV.add(new Drop(rain.x, getHeight())); 
      } 
      iterator.remove(); 

     } 
    } 

    //CREATE NEW RAIN 
    if (Math.random() < mRainChance) { 
     rainV.add(new Rain()); 
    } 
} 

//***************************************** 
class Rain { 
    float x; 
    float y; 
    float prevX; 
    float prevY; 

    public Rain() { 
     Random r = new Random(); 
     x = r.nextInt(getWidth()); 
     y = 0; 
    } 

    public void update() { 
     prevX = x; 
     prevY = y; 

     x += mWind; 
     y += mGravity; 
    } 

    public void draw(Graphics2D g2) { 
     Line2D line = new Line2D.Double(x, y, prevX, prevY); 
     g2.draw(line); 
    } 
} 

//***************************************** 
private class Drop { 

    double x0; 
    double y0; 
    double v0; //initial velocity 
    double t; //time 
    double angle; 
    double x; 
    double y; 

    public Drop(double x0, double y0) { 
     super(); 
     this.x0 = x0; 
     this.y0 = y0; 

     v0 = mDdropInitialVelocity; 
     angle = Math.toRadians(Math.round(Math.random() * 180)); //from 0 - 180 degrees 
    } 

    private void update() { 
     // double g=10; 
     t += mRepaintTimeMS/100f; 
     x = x0 + v0 * t * Math.cos(angle); 
     y = y0 - (v0 * t * Math.sin(angle) - mGravity * t * t/2); 
    } 

    public void draw(Graphics2D g2) { 
     Ellipse2D.Double circle = new Ellipse2D.Double(x, y, mDropDiam, mDropDiam); 
     g2.fill(circle); 
    } 
} 
}