NeoGriever: Aus Winkel und Geschwindigkeit, zielkoordinate erreichnen

Also vorab, das hier habe ich:

function coords(x,y) {  
	this.x = x;  
	this.y = y;  
}  
function sphere(pos,spd) {  
	var self = this;  
	this.position = new coords(0,0);  
	if(typeOf(pos) !== "undefined") {  
		this.position = pos;  
	}  
	this.speed = new coords(0,0);  
	this.getWinkel = function() {  
		var distancey = (self.position.y + self.speed.y) - self.position.y;  
		var distancex = (self.position.x + self.speed.x) - self.position.x;  
		return(Math.atan2(distancey,distancex) * (180 / Math.PI));  
	}  
	this.getSpeed = function() {  
		var start = new coords(0,0);  
		var ziel = new coords(self.speed.x - self.position.x,self.speed.y - self.position.y);  
		var calced = new coords(Math.abs(start.x - ziel.x),Math.abs(start.y - ziel.y));  
		var distance = Math.sqrt(Math.pow(calced.x,2) + Math.pow(calced.y,2));  
		return(distance);  
	}  
}

Verbesserungsvorschläge sind gern gesehen. PS: Kann man eine klasse in einer klasse definieren? Oder gibts ne grundvorlage, welche ähnlich zu meiner coords-klasse is? Hätte gern Alles in Einem.

Was ich jetzt möchte, dass "speed" quasi zurückberechnet werden kann aus winkel und geschwindigkeit.

Quasi:

var sph = new sphere();  
var winkel = sph.getWinkel();  
var speed = sph.getSpeed();  
  
// und das hier will ich haben.  
var targetCoord = sph.getTarget(winkel,speed);

Vorab, um das gleich in einem Beitrag zu packen: Ich will später auch eine funktion (auf basis dieser klasse) haben, welche bei kugeln die korrekte abprall-winkel zurückgibt. Dabei ist die zielkugel (also nicht die ausgangskugel) fix und absorbiert keine geschwindigkeit.

Was ich gaaaaanz genau vorhabe: Wer kennt das Android-Game "Orbital"? Dann dürfte es leicht zu erkennen sein.

→ Aber erstmal ←

Ich möchte aus Winkel und Geschwindigkeit (Wie zuvor bereits berechnet) eine zielkoordinate (ausgehend vom startpunkt 0/0) errechnen. Von 0/0 aus deswegen, um diese auch für die geschwindigkeit zu nutzen.

Wer kann mir da möglichst für laien erklären, wie man das berechnet? PS: Werde meine Lösung natürlich auch hier posten.

⇒ An alle, die mitlesen oder später googeln, sucht in den Antworten von mir. Da könnt ihr ggf. eine Lösung finden.

  1. Hi,

    Ich möchte aus Winkel und Geschwindigkeit (Wie zuvor bereits berechnet) eine zielkoordinate (ausgehend vom startpunkt 0/0) errechnen. Von 0/0 aus deswegen, um diese auch für die geschwindigkeit zu nutzen.

    Wer kann mir da möglichst für laien erklären, wie man das berechnet?

    Von Sinus und Cosinus hast du schon mal gehört …?

    MfG ChrisB

    --
    Autocomplete has spoiled me to a point where it happens every so often that I encounter a CAPTCHA, and I just type in the first character … and then wait for the rest of the code to be automatically suggested :/
    1. Jap. Habe ich. Komme nur nich dahinter, wie ich aus dem Winkel (z. b. 45 grad, wie mir die funktion getWinkel zurückgibt) auf die entsprechenden sin und cos daten komm?

      Wie gesagt. Bin da etwas überfordert grad. Aber nachher werd ich mit Schädelbasisbruch ins Krankenhaus eingeliefert wegen Facepalm.

      1. Hi,

        Jap. Habe ich. Komme nur nich dahinter, wie ich aus dem Winkel (z. b. 45 grad, wie mir die funktion getWinkel zurückgibt) auf die entsprechenden sin und cos daten komm?

        http://de.selfhtml.org/javascript/objekte/math.htm#cos, http://de.selfhtml.org/javascript/objekte/math.htm#sin

        MfG ChrisB

        --
        Autocomplete has spoiled me to a point where it happens every so often that I encounter a CAPTCHA, and I just type in the first character … and then wait for the rest of the code to be automatically suggested :/
        1. Schön. jetzt kann ich schonmal aus Degrees ganz simpel Radiants berechnen. Und weiter? ... Was wird daraus jetzt berechnet?

          1. Hi,

            Und weiter? ... Was wird daraus jetzt berechnet?

            Sinus und Cosinus geben dir die Position auf dem Einheitskreis, wo ein Strahl in deinem Winkel den Kreis schneidet …

            MfG ChrisB

            --
            Autocomplete has spoiled me to a point where it happens every so often that I encounter a CAPTCHA, and I just type in the first character … and then wait for the rest of the code to be automatically suggested :/
            1. Vielen dank. Habe es nun gelöst.

              Falls du Vorschläge hast, wie man es besser hinkriegt, sag ruhig an:

              	this.getCoordSpeed = function(deg,spd) {  
              		var winkel = self.getWinkel();  
              		if(typeof(deg) !== "undefined") {  
              			winkel = deg;  
              		}  
              		var geschw = self.getSpeed();  
              		if(typeof(spd) !== "undefined") {  
              			geschw = spd;  
              		}  
              		var radiants = winkel * (Math.PI / 180);  
              		var position = new coords((Math.cos(radiants) * geschw),(Math.sin(radiants) * geschw));  
              		return(position);  
              	}  
              	this.getTargetCoords = function(deg,spd) {  
              		var winkel = self.getWinkel();  
              		if(typeof(deg) !== "undefined") {  
              			winkel = deg;  
              		}  
              		var geschw = self.getSpeed();  
              		if(typeof(spd) !== "undefined") {  
              			geschw = spd;  
              		}  
              		var position = self.getCoordSpeed(winkel,geschw);  
              		return(new coords(position.x + self.position.x,position.y + self.position.y));  
              	}
              

              getCoordSpeed liefert mir hierbei die geschwindigkeit für X und Y als coords-klasse zurück.
              getTargetCoords liefert mir daraufhin einfach den Zielpunkt ausgehend aus der Grundkoordinate aus der Klasse.

              So. Nun zum komplexeren. Ich habe also Position (x/y), Winkel (deg), Geschwindigkeit (berechnet) und Geschwindigkeit (x/y). Dazu kommt noch der Radius einer Kugel.

              Diese Klasse wird nun auch für eine weitere Kugel verwendet, wobei jedoch die zweite Kugel mit der Geschwindigkeit 0 und unendlicher masse daliegt. Also unbeweglich ist.

              Wie berechne ich korrekt, wohin die anfliegende Kugel hinfliegt? Also Winkel und Geschwindigkeit umrechnen.

  2. Okay. Ich habe einen Berechnungsfehler scheinbar drin :/

    function coords(x,y) {  
    	var self = this;  
    	this.x = x;  
    	this.y = y;  
    	this.toFormatedString = function() {  
    		return(self.x + " / " + self.y);  
    	}  
    }  
    function sphere(pos,spd) {  
    	var self = this;  
    	this.position = new coords(0,0);  
    	this.speed = new coords(100,100);  
    	if(typeof(pos) !== "undefined") {  
    		this.position = pos;  
    	}  
    	if(typeof(spd) !== "undefined") {  
    		this.speed = spd;  
    	}  
    	this.getWinkel = function() {  
    		var distancey = (self.position.y + self.speed.y) - self.position.y;  
    		var distancex = (self.position.x + self.speed.x) - self.position.x;  
    		return(Math.atan2(distancey,distancex) * (180 / Math.PI));  
    	}  
    	this.setWinkel = function(newrad) {  
    		self.speed = self.getCoordSpeed(newrad,self.getSpeed());  
    	}  
    	this.getSpeed = function() {  
    		var start = new coords(0,0);  
    		var ziel = new coords(self.speed.x - self.position.x,self.speed.y - self.position.y);  
    		var calced = new coords(Math.abs(start.x - ziel.x),Math.abs(start.y - ziel.y));  
    		var distance = Math.sqrt(Math.pow(calced.x,2) + Math.pow(calced.y,2));  
    		return(distance);  
    	}  
    	this.setSpeed = function(newspeed) {  
    		self.speed = self.getCoordSpeed(self.getWinkel(),newspeed);  
    	}  
    	this.getCoordSpeed = function(deg,spd) {  
    		var winkel = self.getWinkel();  
    		if(typeof(deg) !== "undefined") {  
    			winkel = deg;  
    		}  
    		var geschw = self.getSpeed();  
    		if(typeof(spd) !== "undefined") {  
    			geschw = spd;  
    		}  
    		var radiants = winkel * (Math.PI / 180);  
    		var position = new coords((Math.cos(radiants) * geschw),(Math.sin(radiants) * geschw));  
    		return(position);  
    	}  
    	this.getTargetCoords = function(deg,spd) {  
    		var winkel = self.getWinkel();  
    		if(typeof(deg) !== "undefined") {  
    			winkel = deg;  
    		}  
    		var geschw = self.getSpeed();  
    		if(typeof(spd) !== "undefined") {  
    			geschw = spd;  
    		}  
    		var position = self.getCoordSpeed(winkel,geschw);  
    		return(new coords(position.x + self.position.x,position.y + self.position.y));  
    	}  
    }  
    var sph = new sphere();  
    sph.setSpeed(10);  
    sph.setWinkel(180);  
    alert(sph.speed.toFormatedString()); // Ausgabe: -10 / 1.2246467991473533e-15
    
    1. Hallo,

      Okay. Ich habe einen Berechnungsfehler scheinbar drin :/

      ich habe eher den Eindruck, dir sind die mathematischen Grundlagen nicht vertraut.

        var radiants = winkel \* (Math.PI / 180);  
      

      Anstatt immer wieder zwischen Gradmaß und Bogenmaß umzurechnen und dadurch unnötige Rundungsfehler zu produzieren, solltest du dir den Gefallen tun und konsequent beim Bogenmaß bleiben. Dann passen auch alle Werte ohne Umrechnen zusammen.

      var sph = new sphere();
      sph.setSpeed(10);
      sph.setWinkel(180);
      alert(sph.speed.toFormatedString()); // Ausgabe: -10 / 1.2246467991473533e-15

      Sieht doch gut aus - abgesehen von dem schon erwähnten vermeidbaren Rundungsfehler. 180° ist vom Ursprung aus an der negativen x-Achse entlang, du solltest also bei (-10/0) ankommen. Wegen deiner Umrechnerei kommst du für y aber nur auf einen sehr kleinen Wert von beinahe 0.

      Und bitte: Anstatt mehrfach ellenlangen Code zu zeigen, solltest du besser erstmal dein Vorhaben in Worten beschreiben. Dann sieht man als Leser nämlich viel besser, ob du irgendwo Denkfehler drin hast und wo. Und dein Vorgehen wird klarer.

      Ciao,
       Martin

      PS: "Formatted" schreibt sich mit Doppel-t.

      --
      TEAM: Toll, Ein Anderer Macht's.
      Selfcode: fo:) ch:{ rl:| br:< n4:( ie:| mo:| va:) de:] zu:) fl:{ ss:) ls:µ js:(
      1. Mein eigentliches Ziel ist, ein Canvas-Game ähnlich diesem hier zu basteln:

        https://www.youtube.com/watch?v=Pu0uz8wdswU

        Bei 30 Sekunden etwa sieht man schön, dass die Kreis-Kollision dort physikalisch korrekt ausgerechnet wird. Was das ganze recht clever macht.

        Und bevor ich mit der GUI anfange, will ich das mathematische schonmal haben.

        Bei 30 Sekunden die Situation, wo er eine feststehende Kugel trifft, fliegt das Geschoss nicht geradlinig von dieser weg, sondern nach der korrekten Kugel-auf-kugel-kollisionsberechnung in einem bestimten winkel weg. Und DIESE berechnung will ich haben. Bin jedoch bisher immer dran gescheitert, Diese zu berechnen.

        Aber wenn du sagst, dass ich die Deg/Rad-Umrechnungen nicht brauche (was eig. logisch erscheint), werd ich das mal ausbauen. Das dürfte das Rundungsproblem ja beheben. :)

        Danke für die Info :)

        1. Habs jetzt so gelöst:

          this.roundingpower = 100000; // eine grundkonstante

          Und überall, wo ich die speed-koordinate festlege, einfach das hier angehängt:

          	self.speed.x = Math.round(self.speed.x * self.roundingpower) / self.roundingpower;  
          	self.speed.y = Math.round(self.speed.y * self.roundingpower) / self.roundingpower;
          

          Okay. Es ist nicht die eleganteste Lösung. Aber dafür steht jetzt bei 180 grad winkel auch -10 / 0 da :P Trotzdem werden genug Nachkommastellen zurückgegeben, dass man damit ziemlich genau arbeiten kann. :)

    2. Hallo NeoGriever,

      irgendwie verstehe ich deine Berechnungen nicht, aber mir sind zwei Dinge aufgefallen:

        var distancey = (self.position.y + self.speed.y) - self.position.y;  
      

      du addierst hier auf eine Position eine Geschwindigkeit. Das geht nicht wegen der unterschiedlichen Einheiten Weg und Weg/Zeit.

        var distancey = (self.position.y + self.speed.y) - self.position.y;  
      

      welches Ergebnis erwartest du hier? für mich ist distancey = self.speed.y.

      Gruß, Jürgen

      1.   var distancey = (self.position.y + self.speed.y) - self.position.y;  
        

        welches Ergebnis erwartest du hier? für mich ist distancey = self.speed.y.

        FACEPALM zum Quadrat o_o XD

        Wird korrigiert XD

  3. Ich benötige immernoch hilfe.

    Um es genauer zu beschreiben, hier ein Bild, was es genau beschreibt :)

    http://n57.imgup.net/veranschaua990.png

    Es ist wahrscheinlich komplizierter als der rest von eben.

    1. hi,

      http://n57.imgup.net/veranschaua990.png

      Eine Skizze ist ein guter Anfang. Bestimme als Nächstes den Punkt auf dem Kreis, da wo das Projektil auftrifft bzw. die Koordinaten für den Punkt bezogen auf Dein darunterliegendes Koordinatensystem. Dann berechne den Winkel der Tangente an diesem Punkt, ebenfalls auf Dein Koordinatensystem bezogen. Schritt für Schritt. Zuletzt wende den Strahlensatz an.

      MfG, Snooker

      --
      Wozu runden Herr Professor, der Kreis ist doch schon rund.
      1. http://w35.imgup.net/ani112f.gif

        Das ist mein aktueller (gedanklicher) Fortschritt.

        http://h30i.imgup.net/Unbenannta60f.png?l=de

        Das habe ich vor.

        ... Und während ich dies schrieb, habe ich einen Geistesblitz ...

        Mittelgeradenaufprallwinkel = Vektor-Winkel - Mittelgeradenwinkel

        Zielwinkel = (Mittelgeradenwinkel - 180) - Mittelgeradenaufprallwinkel
        (- 180 um das ganze umgekehrt zu haben)

        Werd das kurz noch in ne Grafik packen. Dazu verkürzt:
        zw = (mw - 180) - (vw - mw);

        http://y35.imgup.net/wie5fda.gif

        Der Mittelgeradenaufprallwinkel ist der Winkel zwischen der Mittelgeraden und dem Vektorwinkel der Kugel.

        Rein Technisch dürfte das korrekt sein, oder? Sogar Mathematisch nicht die Schwierigkeit.

  4. Meine Herren!

    Ich würde an deiner Stelle zu einer fertigen Physing-Engine greifen, das erspart dir viel Zeit, die du stattdessen dafür nutzen kannst, die eigentliche Spiellogik zu entwickeln.

    Wenn du nur aus Spaß oder zum Üben eine eigene Physik-Engine schreiben willst, dann musst du auch nicht bei 0 anfangen und die ganze euklidische Physik neu erfinden. Dann hangle dich an Tutorials und anderer passender Lektüre entlang.

    --
    “All right, then, I'll go to hell.” – Huck Finn
    1. Deinen Vorschlag in allen Ehren, jedoch bin ich von haus aus dagegen. Denn fertige scripts will ich nicht nutzen, um eben selbst das problem zu lösen und daraus zu lernen.

      Außerdem bin ich eh kurz vor der Lösung :) Siehe

      http://forum.de.selfhtml.org/?t=218151&m=1501154

      :P

  5. Ich habe es jetzt (fast) gelöst. Hier der gesamte Code mit Canvas-Animations-Beispiel:

    http://pastebin.com/4Na1r7P1

    :P

    Mein Problem ist noch, dass bei hoher geschwindigkeit der bewegten kugel die kollision nicht exakt berechnet wird. Also bräucht ich was, was das ganze berechnen kann.

    Ich denke da an sowas wie: distanz des nächsten schrittes zwischen 2 kugeln. Ist kleiner als addierte radien der kugeln, differenz zwischen abstand im nächsten schritt und radien beider kugeln. ... irgend sowas. (hoffe, das versteht jemand. O_O)

    Wenn ich DAS geknackt hab, kann ich mich endlich an die spielengine machen, die das kleinere Übel darstellt.

    1. Meine Herren!

      Mein Problem ist noch, dass bei hoher geschwindigkeit der bewegten kugel die kollision nicht exakt berechnet wird. Also bräucht ich was, was das ganze berechnen kann.

      Die Kollisions-Berechnung findet bei dir in einem einzigen Simulationschritt statt. Und du machst genau einen Simulations-Schritt pro Frame. Das heißt, wenn ein Kreis in einem Frame noch hinter dem anderen steht, aber im nächtsten schon davor, würde das unbemerkt bleiben. Ich kenne mich nicht sonderlich gut mit Physik-Engines aus, aber vermutlich werden die robusten Engines dagegen Interpolations- oder Integrations-Verfahrens anwenden. Sie werden also mehrere Simulations-Schritte pro Frame durchführen. Ich halte es sowieso für sinnvoll, die Framerate von der Simulation zu entkoppeln, das würde so unschöne Methoden wie getSpeedPerFrame() eliminieren.

      Auf der Tutorial-Seite, die ich dir verlinkt habe, werden solche Grundlagen mit Sicherheit besser erklärt und von Leuten, die einen fundierten Background haben.

      --
      “All right, then, I'll go to hell.” – Huck Finn
      1. Iteration wäre eigentlich einfach. Man müsste nur so viele Schritte simulieren, wie die Geschwindigkeit hoch ist. Kurz: Geschwindigkeit = 1 ... 2 ... 3 usw. bis zur eigentlichen geschwindigkeit. Schon hat man jeden Punkt auf der Linie erzeugt.

        Es gäbe aber in diesem Fall einen einfacheren weg. Da die anderen Kugeln (IMMER) fix sind und es nur eine bewegte kugel geben wird, kann man den Zwischenabstand errechnen. Man rechnet einfach Abstand zwischen 2 kugeln und zieht den radius beider kugeln ab. Dies nutzt man als Geschwindigkeit und prüft dann, ob der neue Zielpunkt zu einer Kollision führt. Das wäre 1 Iteration und würde weniger Leistung fressen. Natürlich sollte man es nur mit Kugeln machen, deren entfernung unterhalb der geschwindigkeit der ausgangskugel liegen.

        Bin derzeit dran, dies effektiv umzusetzen.

        1. Meine Herren!

          Iteration wäre eigentlich einfach. Man müsste nur so viele Schritte simulieren, wie die Geschwindigkeit hoch ist. Kurz: Geschwindigkeit = 1 ... 2 ... 3 usw. bis zur eigentlichen geschwindigkeit. Schon hat man jeden Punkt auf der Linie erzeugt.

          Wenn die Geschwindigkeit, Position und Zeit nur diskrete Werte annehmen können, dann ergibt dieser Satz einigermaßen Sinn. Diser Fall ist eher untypisch und beschränkt unnötig. In deinem Beispiel sind die Zeiteinheiten diskret unterteilt in Simulationsschritte. Positionen sind diskret über das Pixel-Raster definiert. Geschwindigkeiten haben aber demnach die Einheit: Pixel pro Simulationsschritt. Und das ist keine diskrete Menge. Deshalb ist die Idee, die da oben formulierst, Nonsens, auf diese Art müsstest du unendlich viele Zwischenschritte interpolieren.

          Es gäbe aber in diesem Fall einen einfacheren weg.

          Na hoffentlich ;)

          Da die anderen Kugeln (IMMER) fix sind und es nur eine bewegte kugel geben wird, kann man den Zwischenabstand errechnen.

          Das kann man zu einem gegebenen Zeitpunkt auch bei bewegten Objekten. (Die heisenbergsche Unschärferelation mal außer Acht gelassen, die spielt bei der Entwicklung von Spiele-Physik-Engines eher keine Rolle :P)

          Man rechnet einfach Abstand zwischen 2 kugeln und zieht den radius beider kugeln ab.

          Wieso nochmal den Radius abziehen? Wenn du den Abstand zweier Kugeln berechnet hast, dann muss da nichts mehr abgezogen werden. Der Oberflächen-Abstand berechnet sich ja schon aus dem Abstand der Mittelpunkte und den Radien. Doppelt gemoppelt ist hier falsch.

          Dies nutzt man als Geschwindigkeit und prüft dann, ob der neue Zielpunkt zu einer Kollision führt.

          Junge, Junge. Würfelst du einfach, wenn es um solche Berechnungen geht? Du spielst mit physikalischen Einheiten herum, als bestehe da überhaupt kein Zusammenhang. Ich weiß das ist hart, aber Informatik und Physik erfordern nun mal Mathematik. Man addiert nicht einfach irgendwelche Geschwindigkeiten zu irgendwelchen Strecken. Mach dir insbesondere mal den Zusammenhang klar, der zwischen Strecke, Geschwindigkeit und Zeit herrscht. Dann wirst du hoffentlich auch auf den Begriff der Ableitung, bzw. der Aufleitung stoßen.

          Das wäre 1 Iteration und würde weniger Leistung fressen. Natürlich sollte man es nur mit Kugeln machen, deren entfernung unterhalb der geschwindigkeit der ausgangskugel liegen.

          Wenn du Schwierigkeiten mit Einheiten hast, dann versuch mal Beispielsätze zu basteln, das hilft oft irgendwelche Irrtümer zu identifizieren. Ich forme mal ein Beispiel aus deinem Satz da oben:

          "Natürlich sollte man es nur Kugeln machen, die weniger als 5 km/h entfernt voneinander sind."

          Nachts ist es kälter als draußen.

          --
          “All right, then, I'll go to hell.” – Huck Finn
          1. Es ist schwierig mit Worten erklärt.

            Nehmen wir an, die Grüne Kugel hat eine höhere geschwindigkeit als der Abstand (von zentren der kugeln aus) zwischen den beiden Kugeln. Dann würde ich es SO berechnen:

            http://z26.imgup.net/beispiel58c4.gif

            Dabei würde ich später noch den Kollisionswinkel berüchsichtigen müssen um den korrekten Abstand für eine Kollission erhalten zu können, wenn diese nicht exakt aufeinandertreffen.

            Verstanden?

            1. Meine Herren!

              Es ist schwierig mit Worten erklärt.

              Die Physik liefert uns da eine präzise Fachsprache, und dieser Zusammenhang zwischen Zeit, Strecke und Geschwindigkeit, um den es hier geht, ist nicht so sonderlich komplex, dass man ihn nicht in Worte fassen könnte.

              Ich habe eher den Eindruck, du weißt gar nicht, was du erklären möchtest, du versuchst die Zusammenhänge irgendwie zu erraten und so zum Ziel zu kommen.

              Nehmen wir an, die Grüne Kugel hat eine höhere geschwindigkeit als der Abstand (von zentren der kugeln aus) zwischen den beiden Kugeln.

              "Nehmen wir an, ich kann schneller Laufen als von Marathon bis Athen." Merkst du wie wenig Sinn so ein Satz ergibt?

              Dann würde ich es SO berechnen:

              http://z26.imgup.net/beispiel58c4.gif

              Schöne Skizze, aber die hilft dir nicht über die physikalischen Grundlagen hinweg. Du berechnest also eine Position, an der es zu einer Kollision käme, unter der Annahme, dass die Objekte ihre Geschwindigkeit und Richtung beibehalten. Und wie soll es dann weiter gehen?

              Dabei würde ich später noch den Kollisionswinkel berüchsichtigen müssen um den korrekten Abstand für eine Kollission erhalten zu können, wenn diese nicht exakt aufeinandertreffen.

              Was ist der Abstand einer Kollision? Möchtest du über den Impuls reden? Ich weiß, das klingt sehr spitzfindig, aber solche Spitzfindigkeiten sind eben elementar dabei, ein Verständnis zu entwickeln.

              Verstanden?

              Du Frage solltest du dir selbst stellen. Wir sprechen immerhin über Schulphysik und du möchtest eine Physik-Engine entwickeln. Auch wenn sie nur sehr bescheiden ausfallen soll und nur der Übung dient, oder gerade weil sie nur der Übung dient, müssen die physikalischen Grundlagen sitzen. Du kommst in Teufels Küche, wenn du dich nicht daran hälst.

              --
              “All right, then, I'll go to hell.” – Huck Finn
              1. Leider muss ich dir sagen, dass du mein Anliegen noch nicht verstanden hast.

                Ich möchte KEINE Physik-Engine umsetzen. Ich will nur EINE funktion aus der Physik-Engine haben ohne dafür eine Physik-Libary zu nutzen, die ellenlang, riesengroß, zwar performant und optimiert, jedoch mit unnötig vielen funktionen bestückt ist, zu verwenden.

                Ich möchte nur Vector und Kreiskollisionsberechnung ... Das hat NIX mit irgendwelchen anderen Physik-Krams zu tun wie Schwerkraft, Reibung, Trägheit usw ...

                Ich möchte nur korrekt berechnet haben, wo die Kugel landen würde, wenn sie so schnell ist, dass sie mit einem animationsschritt über eine vorhandene fixe kugel hinwegspringen würde. Also kollisionsberechnung zwischen 2 bewegungspunten.

                Es sei denn, du erklärst mir, wie ich mit einer bereits bekannten, lizenfreien kostenlosen Javascript-Physik-Engine fixe kugeln und eine bewegliche kugeln dynamisch festlegen kann.

                Danke.

                1. Meine Herren!

                  Ich möchte KEINE Physik-Engine umsetzen.

                  Nenn es wie du möchtest. Du möchtest ein System modellieren, dass physische Kollision zwischen zwei bewegten Objekten erkennt. Das ist eine Funktion, die eine Physik-Engine charakterisiert. Ich nenne das Physik-Engine, du kannst das auch Oliver oder Frosch nennen.

                  Ich will nur EINE funktion aus der Physik-Engine haben ohne dafür eine Physik-Libary zu nutzen, die ellenlang, riesengroß, zwar performant und optimiert, jedoch mit unnötig vielen funktionen bestückt ist, zu verwenden.

                  Das ist ein Motiv, das ich schon verstanden habe. Aber Geschwindigkeit, Strecke und Zeit sind eben die Kenngrößen, die da mit rein spielen. Das sind die Kenngrößen mit denen du dich befassen musst. Anders geht's nicht.

                  Ich möchte nur Vector und Kreiskollisionsberechnung ... Das hat NIX mit irgendwelchen anderen Physik-Krams zu tun wie Schwerkraft, Reibung, Trägheit usw ...

                  Darüber habe ich aber auch gar nicht gesprochen. Ich habe nur noch den Impuls zur Sprache gebracht. Wenn du dir die Einheit eines Impulses ansiehst, dann wirst du wissen wieso.

                  Ich möchte nur korrekt berechnet haben, wo die Kugel landen würde, wenn sie so schnell ist, dass sie mit einem animationsschritt über eine vorhandene fixe kugel hinwegspringen würde. Also kollisionsberechnung zwischen 2 bewegungspunten.

                  Dann setz dich mit den Grundlagen auseinander. Kerzen auspusten und hoffen wird dich nicht ans Ziel bringen.

                  Es sei denn, du erklärst mir, wie ich mit einer bereits bekannten, lizenfreien kostenlosen Javascript-Physik-Engine fixe kugeln und eine bewegliche kugeln dynamisch festlegen kann.

                  Ich habe dir bereits Lektüre emppfohlen, die genau das macht. Und ich habe dir eine gesamte Tutorial-Reihe empfohlen, die sich mit den elementaren Implementations-Details einer Physik-Engine bzw. eines "Frosches" befasst.

                  --
                  “All right, then, I'll go to hell.” – Huck Finn
            2. Hallo NeoGriever,

              ... höhere geschwindigkeit als der Abstand ...

              vor vielen Jahren hat ein Komiker (Tegtmeier) versucht zu erklären, wie schnell man im Dunkeln fahren darf:

              "Man darf nicht schneller fahren, als man weit gucken kann."

              Gruß, Jürgen

  6. Om nah hoo pez nyeetz, NeoGriever!

    Du kannst hier anklickbare Links erzeugen, entweder mithilfe der Leiste oberhalb des Antwortfeldes oder durch die Angabe von

    [lіnk:http://example.com@title=Linktext]  
    
    

    ergibt: Linktext

    Matthias

    --
    Der Unterschied zwischen Java und JavaScript ist größer als der zwischen Verl und Verlies.