एक स्टार के गुरुत्वाकर्षण खींच अनुकरण?

Question

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

मुख्य वर्ग:

shootingStar वर्ग के

import acm.graphics.GCompound; 
    import acm.graphics.GImage; 
    import acm.graphics.GLabel; 
    import acm.graphics.GLine; 
    import acm.graphics.GMath; 
    import acm.graphics.GObject; 
    import acm.graphics.GPen; 
    import acm.graphics.GPoint; 
    import acm.graphics.GRect; 
    import acm.graphics.GOval; 
    import acm.graphics.GRectangle; 
    import acm.program.GraphicsProgram; 
    import acm.util.RandomGenerator; 
    import java.awt.Color; 
    import java.awt.event.MouseEvent; 
    import java.util.*; 

    public class Space extends GraphicsProgram { 
     public static int APPLICATION_WIDTH = 1000; 
     public static int APPLICATION_HEIGHT = 1000; 
     private int size = 15; 
     public static double pMass = 1000; 
     public static int sMass = 20; 
     public static double G = 200; 
     private RandomGenerator rand = new RandomGenerator(); 
     GOval planet, tempstar; 
     shootingStar star; 
     GLine line; 
     double accel, xAccel, yAccel, xspeed, yspeed, angle; 


     public void init(){ 
     planet = new GOval(APPLICATION_WIDTH/2, APPLICATION_HEIGHT/2, 30, 30); 
     planet.setFilled(true); 
     planet.setFillColor(rand.nextColor()); 
     add(planet); 

     } 


     public void mousePressed(GPoint point) { 
     // draw a line 
     tempstar = new GOval(point.getX() - size/2, point.getY() - size/2, size, size); 
     tempstar.setFilled(true); 
     tempstar.setColor(rand.nextColor()); 
     add(tempstar); 
     line = new GLine(tempstar.getX() + size/2, tempstar.getY() + size/2, 
    point.getX(), point.getY());        
     add(line); 
     line.setVisible(true); 
     } 

     public void mouseDragged(GPoint point) { 
     line.setEndPoint(point.getX(), point.getY()); 
     } 

     public void mouseReleased(GPoint point){ 
     xspeed =    
    -.05*GMath.cosDegrees(getAngle(line))*GMath.distance(line.getStartPoint().getX(),   
    line.getStartPoint().getY(), line.getEndPoint().getX(), line.getEndPoint().getY()); 
     yspeed = 
    .05*GMath.sinDegrees(getAngle(line))*GMath.distance(line.getStartPoint().getX(), 
    line.getStartPoint().getY(), line.getEndPoint().getX(), line.getEndPoint().getY()); 
     System.out.println(xspeed + " " + yspeed); 
     star = new shootingStar(xspeed, yspeed, this); 
     if(xspeed != 0) 
      add(star, tempstar.getX(), tempstar.getY()); 
     new Thread(star).start(); 
     remove(tempstar); 
     remove(line); 

     } 

     private double getAngle(GLine line) { 
     return GMath.angle(line.getStartPoint().getX(), line.getStartPoint().getY(), 
          line.getEndPoint().getX(), line.getEndPoint().getY()); 
     } 


     public void checkPlanet(){ 
     accel = .06*GMath.distance(star.getX(), star.getY(), planet.getX(), 
    planet.getY()); 
     angle = correctedAngle(GMath.angle(planet.getX(), planet.getY(), star.getX(), 
    star.getY()));  
     xAccel = accel*GMath.cosDegrees(GMath.angle(planet.getX(), planet.getY(), 
    star.getX(), star.getY())); 
     yAccel = accel*GMath.sinDegrees(GMath.angle(planet.getX(), planet.getY(), 
    star.getX(), star.getY())); 

     double newX = xspeed - xAccel*.01; 
     double newY = yspeed + yAccel*.01; 

     xspeed = newX + xAccel*Math.pow(.01, 2)/2; 
     yspeed = newY + yAccel*Math.pow(.01, 2)/2; 

     star.setSpeed(xspeed, yspeed); 


     } 

     public double correctedAngle(double x) { 
     return (x%360.0+360.0+180.0)%360.0-180.0; 
    } 
    } 

प्रासंगिक भागों:

 public void run() { 
     // move the ball by a small interval 
     while (alive) { 
     oneTimeStep(); 
     } 
     } 

     // a helper method, move the ball in each time step 
     private void oneTimeStep() { 
     game1.checkPlanet(); 
     shootingStar.move(xSpeed, ySpeed); 
     pause(20); 
     } 

     public void setSpeed (double xspeed, double yspeed){ 
     xSpeed = xspeed;; 
     ySpeed = yspeed; 

     } 
    } 

---

संपादित करें:

वर्तमान मुख्य क्लास विधि:

public void checkPlanet(){ 
     double xDistance = star.getX() - planet.getX(); 
     double yDistance = star.getY() - planet.getY(); 
     double distance = Math.sqrt(Math.pow(xDistance, 2) + Math.pow(yDistance, 2)); 
     accel = G*pMass/Math.pow(distance, 2); 

     xAccel = accel * xDistance/distance; 
     yAccel = accel * yDistance/distance; 

      xspeed += xAccel; 

     yspeed += yAccel; 

     star.setSpeed(xspeed, yspeed); 

    } 

वर्तमान स्टार वर्ग विधि:

public void run() { 
     while (alive) { 
      oneTimeStep(); 
     } 
     } 

     private void oneTimeStep() { 
     game1.checkPlanet(); 
     shootingStar.move(xSpeed, ySpeed); 
     pause(20); 
     } 

     public void setSpeed (double xspeed, double yspeed){ 
     xSpeed = xspeed;; 
     ySpeed = yspeed; 

     } 
    } 

Answer 1

मुझे यकीन है कि नहीं हूँ, लेकिन हिस्सा है जहाँ आप कुछ इस तरह के xAccel और yAccel मूल्यों की गणना बदलने की कोशिश।

xDistance = XComponentObject1 - XComponentObject2; 

yDistance = YComponentObject1 - YComponentObject2; 

(xDistance and yDistance can have negative values) 

Distance = sqrt(xDistance^2 + yDistance^2); 

gConstant = constant Value for gravitational strenght in your world; 

MassObject1 = some Mass; 

MassObject2 = some other Mass; 

Accel = gConstant*MassObject1*MassObject2/(Distance^2); 

''NOW COMES THE IMPORTANT PART'' 

xAccel = Accel * xDistance/Distance; 

yAccel = Accel * yDistance/Distance; 

मैं ज्या और कोज्या के साथ अपने पूरे yadayada मुश्किल से trackdown-त्रुटियों की एक पूरी गुच्छा बनाता है लगता है।

Answer 2

वाह, यह आपके द्वारा किए जाने वाले कार्यों की तुलना में बहुत अधिक प्रयास है।

यदि बोर्ड बोर्ड पर है तो यह वस्तु से दूरी की गणना करता है। यदि यह डी से कहीं दूर है तो कुछ भी नहीं। यदि यह दूर है तो यह वस्तुओं गुरुत्वाकर्षण खींच के भीतर है। ऑब्जेक्ट पर इंगित करने के लिए बस थोड़ी मात्रा में वेग जोड़ें। मान लीजिए कि यह 1000 एक्स दूर और 500 ज़ेड दूर था। बस कुछ सरल करें जैसे 100 से विभाजित करें, और ऑब्जेक्ट वेग में जोड़ें ताकि यह ऑब्जेक्ट की ओर 10 x और 5 y को स्थानांतरित कर सके। प्रत्येक बार जब आप अद्यतन फिर से वेग जोड़ते हैं।

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

यह एक गेम के लिए काफी अच्छा है। आप एक सिम्युलेटर नहीं बना रहे हैं। आप एक खेल बना रहे हैं।