Kugel Kollision

[_crypto_]

Also ich habe ein problem beim abarbeiten dieser kleinen anleitung:
Hier

// b1, b2 Kugeln
 
var s1 : Point = new Point( b1.x, b1.y );
var s2 : Point = new Point( b2.x, b2.y );
 
var a : Vector = b1.velocity;
var b : Vector = b2.velocity;
var c, d, impulse, impact : Vector;
 
var mass1 : Number = b1.radius;
var mass2 : Number = b2.radius;
var impactSpeed : Number;
 
impact = Vector.subtract( b, a );
// impulse = normalise( s2 - s1 ); was ist hier gemeint? schließlich muss ein Vektor rauskommen???
 
impactSpeed = Vector.dotProduct( impact, impulse );
impulse.multiply( Math.sqrt( impactSpeed * mass1 * mass2 );
 
c = Vector.add( a, impulse.divide( mass1 ) );
d = Vector.subtract( b, impulse.divide( mass2 ) ); 

ich kann auch gerne meine Vektorklasse angeben, aber ich versteh nich was ich da normalisieren soll?? ich hab doch keinen vektor was is denn dann normalisieren, in dem kontext?

danke schonmal ^^

[hgseib]

http://de.wikipedia.org/wiki/Einheitsvektor

gibt die relative grössen der richtungen an


praktische anwendung z.b.
http://www.seibsprogrammladen.de/fra.../Schnittpunkte
Linie durch 3-Eck im raum
und
Hilfsfunktionen: (darüber)
function vector_mul(a, m) { return {x:a.x*m, y:a.y*m, z:a.z*m}; }
function vector_len(a) { return Math.sqrt(a.x*a.x+a.y*a.y+a.z*a.z); }
function vector_norm(a) { return vector_mul(a,1/vector_len(a)); }

[_crypto_]

sry vllt falsch ausgedrückt aber ...

ich weiß was einheitsvektoren sind
ich hab doch gesagt ich verstehe nicht wie ich das gemeint ist,
die differenz der punkte und damit irgendwie normalisieren???

[hgseib]

ebenfalls sorry, das ich nicht weiss, was du weisst.

x/y/(z wenn im raum berechnet)- koordinaten eines punktes bzw. die der differenz von zwei punkten sind ein vektor (das weisst du bestimmt auch).

durch das normalisieren (weisst du selbst, wie du schreibst) erhält man den prozentanteil wieviel in jede richtung.
"..Both impulses are equal in size, and exactly opposite in direction (Green line).."
die grüne linie nicht absolut, sondern relativ.

damit erfolgt die berechnung des "geraden stosses" (was du bestimmt auch weisst):
"..
Now, the impulse is multiplied by the impact speed and the masses:
impulse = impulse * square_root(ImpactSpeed * mass1 * mass2)
and the impulse can be applied to the initial velocities to get the resultant velocities:
c = a + impulse / mass1
d = b - impulse / mass2
.."

durch impulse aufgeteilt wieviel % in die jeweilige x/y/(z)- richtung (weisst du bestimmt auch).

[_crypto_]

ja nur hab ich schwierigkeiten mit dem umsetzen:
ich hätte es so gemacht, aber so klapt keine saubere kollision.

impuls = new Vector( b2.x - b1.x, b2.y - b1.y );
impuls.normalize(); 

wie gesagt, ergibt nicht das gewünschte resultat.

Vektorklasse:

package
{
    public class Vector
    {
        public var x : Number;
        public var y : Number;
        
        public static function add( v1 : Vector, v2 : Vector ) : Vector
        {
            return new Vector( v1.x + v2.x, v1.y + v2.y );
        }
        
        public static function subtract( v1 : Vector, v2 : Vector ) : Vector
        {
            return new Vector( v1.x - v2.x, v1.y - v2.y );
        }
        
        public static function project( v1 : Vector, v2 : Vector ) : Vector
        {
            var dp : Number = Vector.dotProduct( v1, v2 );
            var px : Number = ( dp / ( v2.length() * v2.length() ) ) * v2.x;
            var py : Number = ( dp / ( v2.length() * v2.length() ) ) * v2.y;
            
            return new Vector( px, py );
        }
        
        public static function dotProduct( v1 : Vector, v2 : Vector ) : Number
        {
            return ( v1.x * v2.x + v1.y * v2.y );
        }
        
        public static function crossProduct( v1 : Vector, v2 : Vector ) : Number
        {
            return ( v1.x * v2.y - v1.y * v2.x );
        }
        
        public function Vector( x : Number = 0, y : Number = 0 )
        {
            this.x = x;
            this.y = y;
        }
        
        public function length() : Number
        {
            return Math.sqrt( x * x + y * y );
        }
        
        public function angle() : Number
        {
            return Math.atan2( y, x );
        }
        
        public function normalize() : Vector
        {
            var l : Number = this.length();
            
            x /= l;
            y /= l;
            
            return this;
        }
        
        public function multiply( f : Number ) : Vector
        {
            x *= f;
            y *= f;
            
            return this;
        }
        
        public function divide( f : Number ) : Vector
        {
            x /= f;
            y /= f;
            
            return this;
        }
        
        public function rotateBy( angle : Number ) : Vector
        {
            var ca : Number = Math.cos( angle );
            var sa : Number = Math.sin( angle );
            
            x = x * ca - y * sa;
            y = x * sa + y * ca;
            
            return this;
        }
        
        public function rotateTo( angle : Number ) : Vector
        {
            var l : Number = this.length();
            x = l * Math.cos( angle );
            y = l * Math.sin( angle );
            
            return this;
        }
        
        public function getOrthogonal() : Vector
        {
            return new Vector( -y, x );
        }
        
        public function copy() : Vector
        {
            return new Vector( x, y );
        }
    }
} 

Mainklasse und die Kollision

package
{
    import flash.display.Sprite;
    import flash.events.Event;
    
    [SWF(width='500', height='500', backgroundColor='0xFFFFFF', frameRate='40')]
    
    public class Billard extends Sprite
    {
        private var b1 : BillardBall = new BillardBall( 250, 100, new Vector( 0, 2 ), 5 );
        private var b2 : BillardBall = new BillardBall( 259, 250, new Vector( 0, -2 ), 5 );
        
        public function Billard()
        {
            this.addEventListener( Event.ENTER_FRAME, enterFrame );
        }
        
        private function enterFrame( event : Event ) : void
        {
            graphics.clear();
            
            b1.forceScreen( stage );
            b2.forceScreen( stage );
            
            if( b1.hasCollision( b2 ) || b2.hasCollision( b1 ) )
            {
                var a : Vector = b1.velocity;
                var b : Vector = b2.velocity;
                var impulse : Vector, impact : Vector;
                
                var mass1 : Number = b1.radius;
                var mass2 : Number = b2.radius;
                var impactSpeed : Number;
                
                impact = Vector.subtract( b, a );
                impulse = new Vector( b1.x - b2.x, b1.y - b2.y ).normalize();
                
                impactSpeed = Vector.dotProduct( impact, impulse );
                impulse.multiply( Math.sqrt( impactSpeed * mass1 * mass2 ) );
                
                b1.velocity = Vector.add( a, impulse.divide( mass1 ) );
                b2.velocity = Vector.subtract( b, impulse.divide( mass2 ) );
            }
            
            b1.solve();
            b2.solve();
            
            b1.draw( graphics );
            b2.draw( graphics );
            
            Time.update();
        }
    }
} 

[hgseib]

wurzel aus negativen zahlen geht nicht

[_crypto_]

Zitat von hgseib

wurzel aus negativen zahlen geht nicht

ich bin so dumm
hätt mir klar sein sollen das das punktprodukt auch negativ sein kann ^^

danke

für die viele hilfe gibts nun das
"Billard"

[hgseib]

na das lege ich mir doch unter den weihnachtsbaum ;-)