Kreis - Kreis Kollision

  • GM 8

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Kreis - Kreis Kollision

    Hallo,
    ich melde mich seit langem mal wieder.
    Ich habe jetzt schon eine Weile gesucht, aber noch nicht ganz was passendes gefunden. (ich habe es auch mit ball zu ball collision etc. probiert)

    Gibt es irgendwo schon eine vernüftige "Ball-zu-Ball" collision? Dabei habe ich einen kleinen Ball und einen größeren. Ziel ist es, mit der Größeren Kreis auf dem kleinen durch bounces zu balancieren. D.h. man springt auf den kleinen Ball und wird dann je nach Winkel stärker zurück befördert. Beim Winkel 90° wird jedoch wieder verkleinert mit dem Faktor *0,3, d.h. der Bounce wird wieder kleiner. Also, je schräger man den kleinen Kreis trifft, desto stärker ist die "Rückfederung".
    Ziel ist, sich immer höher "zu pendeln" in dem man auf dem kleinen Kreis "rumspringt".

    Ich suche also eine gute Kreis-Kreis Kollison. Gibt es da schon etwas?

    Vielen Dank. Gruß Paul

  • Ich dachte da eigentlich mehr an eine mathematische Lösung. Allerdings habe ich jetzt was gefunden, was mein Problem noch eher behandelt.
    Aus einem english-sprachigen Programmierer Forum stammt folgendes (Circle/LineSeg coll):

    GML-Quellcode

    1. siehe unten


    argument0.vel_x += px;
    argument0.vel_y += py;
    Das kommt von mir, und dient dazu, die Höhe des zweiten Balls zu erhöhen. Das ganze funktioniert auch wunderbar.
    Allerdings bin ich jetzt kein Mathematik-Fan und suche im Moment eine Möglichkeit, den Bounce etwas zu reduzieren also, kleiner zu machen.
    Kann da jemand den Teil in den Formeln finden, in dem man das anders Berechnen könnte? Ein einfach + bzw. - am Ende der Formel führt zu unerwünschten Effekten.

    Gruß Paul

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Phasm ()

  • Hey nochmal,
    gibt es jemand hier, der die ganze Sach gut versteht, und mir sagen könnte, wie man den "Bounce" kleiner machen kann?
    Hier nochmal:
    Die "detect":

    GML-Quellcode

    1. // function CL_Intersect(argument0, arugment1)
    2. {
    3. x0 = argument0.tempx;
    4. y0 = argument0.tempy;
    5. x1 = argument1.x1;
    6. y1 = argument1.y1;
    7. x2 = argument1.x2;
    8. y2 = argument1.y2;
    9. n = abs((x2-x1)*(y1-y0)-(x1-x0)*(y2-y1));
    10. d = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
    11. dist = n/d;
    12. if(dist > argument0.radius) return false;
    14. d1 = sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1));
    15. if((d1-argument0.radius) > d) return false;
    17. d2 = sqrt((x0-x2)*(x0-x2)+(y0-y2)*(y0-y2));
    18. if((d2-argument0.radius) > d) return false;
    20. return true;
    21. }
    Alles anzeigen

    Und die "Reaction":

    GML-Quellcode

    1. // function CL_Reaction(argument0, argument1)
    2. {
    3. dx = 0;
    4. dy = 0;
    5. px = 0;
    6. py = 0;
    7. pen = 0;
    9. xx = argument0.tempx;
    10. yy = argument0.tempy;
    11. r = argument0.radius;
    12. x0 = argument1.x1;
    13. y0 = argument1.y1;
    14. x1 = argument1.x2;
    15. y1 = argument1.y2;
    16. lx = x1 - x0; //lx,ly is a vector parallel to the line
    17. ly = y1 - y0;
    18. len = sqrt(lx*lx + ly*ly);
    19. if(len == 0)
    20. {
    21. return 0;
    22. }
    23. rx = lx/len; //rx,ry is the unit direction vector of the lineseg
    24. ry = ly/len;
    26. nx = -ry; //nx,ny is a vector perpendicular to the line
    27. ny = rx;
    29. dx = (xx - x0); //dx,dy is the vector from x0,y0 to the circle
    30. dy = (yy - y0);
    32. dpPerp = dx*rx + dy*ry; //length of dx,dy projected onto the lineseg's direction
    33. if(dpPerp < 0)
    34. {
    35. //circle is closer to the endpoint x0,y0 than the line, project out of point x0,y0
    36. len = sqrt(dx*dx + dy*dy);
    37. pen = r - len;
    38. if(0 < pen)
    39. {
    40. //project out of the endpoint
    41. dx /= len;
    42. dy /= len;
    43. px = dx*pen;
    44. py = dy*pen;
    45. }
    46. }
    47. else
    48. {
    49. if(len < dpPerp)
    50. {
    51. //circle is closer to the endpoint x1,y1 than the line, project out of point x1,y1
    52. dx -= lx; //dx,dy is now the vector from x1,y1 to the circle
    53. dy -= ly;
    54. len = sqrt(dx*dx + dy*dy);
    55. pen = r - len;
    56. if(0 < pen)
    57. {
    58. //project out of the endpoint
    59. dx /= len;
    60. dy /= len;
    61. px = dx*pen;
    62. py = dy*pen;
    63. }
    65. }
    66. else
    67. {
    68. //circle is closer to the lineseg; project out of it
    69. dp = dx*nx + dy*ny;//dp is length of dx,dy when measured/projected onto the line's normal
    71. pen = abs(dp) - r;
    72. if(pen < 0)
    73. {
    74. //circle is inside the line; project it out along the normal
    75. if(0 < dp)
    76. {
    77. //circle is on the RHside of the line, should be projected out the +ve normal
    78. pen *= -1;
    79. }
    80. px = nx*pen;//px,py is the penetration vector which pushes the circle out of the line
    81. py = ny*pen;
    82. }
    83. }
    84. }
    86. argument0.vel_x += px;
    87. argument0.vel_y += py;
    88. }
    Alles anzeigen


    Wie gesagt, es funktioniert ja soweit, allerdings sind mir die "Rückschläge" zu stark.

    Gruß Paul