模擬雨

Question

我正在用java製作一個遊戲，我想創建一個正在傾盆大雨的模擬雲。下雨時雲應該向右移動。移動雲是沒有問題的。這是我正在努力的雨。

我想的所做的是用一個定時器來繪製一個矩形什麼，那應該看起來像在隨機x值雲內雨聲。然後每100毫秒加1到滴的y值。但我不想爲每次降雨創建100個不同的矩形，x變量和y變量。

任何想法我可以做到這一點？建議感激！

---

這是一個2D遊戲..對不起。

Answer 1

我會建議只是存儲的值作爲對象的ArrayList。

class Raindrop { 
    private int x; 
    private int y; 

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

然後使用泛型類型創建ArrayList。

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

每一滴秋天，

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

Answer 2

一種方法是考慮在影院選取框。您可以拍攝一系列燈泡，通過依次點亮和熄滅燈泡，您可以模擬直線運動。

以同樣的方式，而不是創造雨滴和動畫的運動，爲什麼不創建多個雨滴是不可見的，顯示和隱藏他們的序列來模擬向下運動。然後，您將有一系列代表雨滴軌跡的數組，並且您只需循環，隱藏當前數組，然後遞增數組指針並顯示該數組。

Answer 3

可以使用粒子系統或使用雨滴的矢量和動畫他們每隔X毫秒。一個鏈接到一個粒子系統庫：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

是認爲雨滴被編程的要求？傳統上，這將通過幾個雨滴來完成，這些雨滴會置於雲下並生成動畫，以便看起來像雨正在下降。

Answer 5

這裏是我的Java（鞦韆）實現與滴，飛濺，風和重力

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