Beschleunigung einer PictureBox via Pfeiltasten

  • C#
  • .NET 4.5

Es gibt 31 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Beschleunigung einer PictureBox via Pfeiltasten

    Hi zusammen,

    ich bin aktuell damit Beschäftigt eine beschleunigte Bewegung einer PictureBox zu realisieren. Mein Vorhaben besteht darin via Pfeiltasten die PictureBox zu bewegen. Das Ziel sollte darin bestehen, dass erstens die PictureBox beschleunigt bewegt wird d.h. wir eine Pfeiltaste länger betätigt, dann soll die Geschwindigkeit mit der sich die Box bewegt auch erhöht werden. Eein trivialer Ansatz wäre Position + Konstanter Wert, aber das hatte ich schon und soll durch die Beschleunigung ersetzt werden. Zweitens muss die PictureBox im Rahmen der Form bleiben, d.h. sie sollte sich nicht außerhalb des Formbereiches bewegen können.

    Das hier ist mein aktueller Stand, hier fehlt noch die Bereichseingrenzung der Form. Das Problem ist, dass wenn ich zu stark beschleunige ich außerhalb des Formbereichs komme... Auch würde mich interessieren, ob diese beschleuinigte Bewegung noch verbessert werden könnte. Beispielsweise nutze ich für time nur eine Variable die hochzählt, vllt. geht das auch besser?! Ich bastle natürlich weiter, aber das ist der Stand den ich jetzt nach ein paar Minuten basteln habe:

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Diagnostics;
    6. using System.Drawing;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Threading.Tasks;
    10. using System.Windows.Forms;
    11. namespace MovePictureBox
    12. {
    13. public partial class Form1 : Form
    14. {
    15. public static double acceleration = 0.02;
    16. public static double velocity;
    17. public static double time = 0;
    18. public Form1()
    19. {
    20. InitializeComponent();
    21. }
    22. private void Form1_KeyDown(object sender, KeyEventArgs e)
    23. {
    24. time += 1;
    25. velocity += acceleration * time;
    26. Debug.WriteLine((int)(velocity));
    27. // Debug.WriteLine(e.KeyValue);
    28. if (e.KeyValue == 38)
    29. {
    30. if (moveAllowed())
    31. {
    32. pictureBox1.Location = new Point(pictureBox1.Location.X, pictureBox1.Location.Y - (int)(velocity * time + 1));
    33. }
    34. }
    35. if(e.KeyValue == 39)
    36. {
    37. if (moveAllowed())
    38. pictureBox1.Location = new Point(pictureBox1.Location.X + (int)(velocity * time + 1), pictureBox1.Location.Y);
    39. }
    40. if (e.KeyValue == 40)
    41. {
    42. if (moveAllowed())
    43. pictureBox1.Location = new Point(pictureBox1.Location.X, pictureBox1.Location.Y + (int)(velocity * time + 1));
    44. }
    45. if(e.KeyValue == 37)
    46. {
    47. if (moveAllowed())
    48. pictureBox1.Location = new Point(pictureBox1.Location.X - (int)(velocity * time + 1), pictureBox1.Location.Y);
    49. }
    50. }
    51. private void Form1_KeyUp(object sender, KeyEventArgs e)
    52. {
    53. time = 0;
    54. velocity = 0;
    55. }
    56. public bool moveAllowed()
    57. {
    58. int x = pictureBox1.Location.X;
    59. int y = pictureBox1.Location.Y;
    60. int height = this.Height;
    61. int width = this.Width;
    62. label1.Text = x + " " + y;
    63. label2.Text = height + " " + width;
    64. if(y < height && x < width && y > 0 && x > 0)
    65. {
    66. return true;
    67. }
    68. return false;
    69. }
    70. }
    71. }

    VB.neter0101 schrieb:

    wird eine Pfeiltaste länger betätigt, dann soll die Geschwindigkeit mit der sich die Box bewegt auch erhöht werden.
    Das kannst Du im KeyPress-Event machen, da kommt das Auto-Repeat der tastatur-Funktionalität an.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Danke für die Anmerkung, ich glaube jedoch, dass dies für meine weitere Planung nicht funktioniert, da ich später vorhabe via registrierter Key Kombi (win api) unabhängig von der Form etwas zu steuern. Wie ist denn grundsätzlich die Beschleunigung zu bewerkstelligen? Mich interessiert hier speziell wie die beschleunigte Bewegung umzusetzen ist (da ich meinen Code für nicht vernünftig halte...).
    Poste zunächst eine vollständige und belastbare Aufgabenstellung / Problembeschreibung, sonst backen wir Spekulatius.

    VB.neter0101 schrieb:

    Wie ist denn grundsätzlich die Beschleunigung zu bewerkstelligen?
    Mach Dir ein UserControl mit einem Timer, dessen Intervall Du entsprechend Deinen Wünschen dynamisch veränderst.
    Start bei KeyDown, Stop bei KeyUp und Senden eines Events im Timer-Takt.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    VB.neter0101 schrieb:

    Wie ist denn grundsätzlich die Beschleunigung zu bewerkstelligen?
    Meiner Meinung nach geht sowas nicht ohne ein Datenmodell - und seien es auch selbstgefrickelte Klassen.
    Ein bewegliches Objekt - ich nenne sowas Moveable - hat Höhe, Breite, Position (des Mittelpunktes, tätich vorschlagen), Geschwindigkeit, Beschleunigung
    Position, Geschwindigkeit und Beschleunigung sollten Vektoren sein.
    Evtl. kommt später noch Masse hinzu, und dann modelliert man, wie eine Kraft (auch ein Vektor, aber nicht Moveable-Member) auf eine Masse wirkt.

    Die Picturebox (wenn man denn eine dafür nimmt) soll das Moveable anzeigen, sollte es aber nicht sein.

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Danke für eure Beiträge, das schein alles in die richtige Richtung zu gehen.

    Ich breche das einfach mal auf den Kernpunkt runter: Um was es mir geht ist eine weiche Bewegung nicht ruckartig der PictureBox, die soll sich nach Möglichkeit natürlich bewegen. Vllt als Addon: Später will ich das für eine Cursor Steuerung verwenden :)

    @RodFromGermany, bezüglich des Timers meintest du sowas wie:

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Diagnostics;
    6. using System.Drawing;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Threading.Tasks;
    10. using System.Windows.Forms;
    11. namespace MovePictureBox
    12. {
    13. public partial class Form1 : Form
    14. {
    15. public static int acc = 1;
    16. public static int maxAcc = 100;
    17. public Form1()
    18. {
    19. InitializeComponent();
    20. timer1.Interval = 75;
    21. }
    22. private void Form1_KeyDown(object sender, KeyEventArgs e)
    23. {
    24. showLabels();
    25. timer1.Enabled = true;
    26. timer1.Start();
    27. if (e.KeyValue == 38)
    28. {
    29. int x = pictureBox1.Location.X;
    30. int y = pictureBox1.Location.Y;
    31. int height = this.Height;
    32. int width = this.Width;
    33. if(pictureBox1.Location.Y - (int)(acc) >= 0)
    34. {
    35. pictureBox1.Location = new Point(pictureBox1.Location.X, pictureBox1.Location.Y - (int)(acc));
    36. }
    37. }
    38. if (e.KeyValue == 39)
    39. {
    40. int x = pictureBox1.Location.X;
    41. int y = pictureBox1.Location.Y;
    42. int height = this.Height;
    43. int width = this.Width;
    44. if (pictureBox1.Location.X + acc <= width - 42)
    45. {
    46. pictureBox1.Location = new Point(pictureBox1.Location.X + acc, pictureBox1.Location.Y);
    47. }
    48. }
    49. if (e.KeyValue == 40)
    50. {
    51. int x = pictureBox1.Location.X;
    52. int y = pictureBox1.Location.Y;
    53. int height = this.Height;
    54. int width = this.Width;
    55. if (pictureBox1.Location.Y + acc <= height - 64)
    56. {
    57. pictureBox1.Location = new Point(pictureBox1.Location.X, pictureBox1.Location.Y + acc);
    58. }
    59. }
    60. if (e.KeyValue == 37)
    61. {
    62. if (pictureBox1.Location.X - (int)(acc) >= 0)
    63. {
    64. pictureBox1.Location = new Point(pictureBox1.Location.X - (int)(acc), pictureBox1.Location.Y);
    65. }
    66. }
    67. }
    68. private void Form1_KeyUp(object sender, KeyEventArgs e)
    69. {
    70. timer1.Enabled = false;
    71. acc = 1;
    72. }
    73. public void accelerate()
    74. {
    75. if (acc <= maxAcc)
    76. acc = acc + 1;
    77. }
    78. public void showLabels()
    79. {
    80. int x = pictureBox1.Location.X;
    81. int y = pictureBox1.Location.Y;
    82. int height = this.Height;
    83. int width = this.Width;
    84. label1.Text = "X: " + x + " Y: " + y;
    85. label2.Text = "H: " + height + " W: " + width;
    86. label3.Text = "Acc: " + acc;
    87. }
    88. private void timer1_Tick(object sender, EventArgs e)
    89. {
    90. accelerate();
    91. }
    92. }
    93. }


    Allerdings ist das m.M.n noch immer etwas am Ruckeln...

    Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von „VB.neter0101“ ()

    VB.neter0101 schrieb:

    noch immer etwas am Ruckeln...

    RodFromGermany schrieb:

    Poste zunächst eine vollständige und belastbare Aufgabenstellung / Problembeschreibung, sonst backen wir Spekulatius.
    Was soll denn passieren? Dies bitte detailliert beschreiben.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Ich habe eine Windows Forms Anwendung, auf der sich eine Picturebox befindet. Die Idee ist nun die Pfeiltasten meiner Tastatur abzufangen und die Picturebox zu bewegen. Das heißt halte ich z.B. die linke Pfeiltaste gedrückt, dann soll sich die Picturebox nach links bewegen. Für die anderen Pfeiltasten eben vice versa. Was mache ich bisher um das umzusetzen? Ich fange via Form1_KeyDown die Pfeiltasten ab und entsprechend der jeweiligen Pfeiltaste bewege ich die Picturebox von ihrer aktuellen Position um X Pixel nach links/rechts/oben/unten. Das führt leider zu einer ruckartigen und keiner flüssigen Bewegung, ich habe das mal mit dem Bild unten animiert, was ich meine... Alternativ im Anhang ist eine Exe mit der Ihr das mal selbst testen könnt. Was ist mein Ziel? Ich möchte eine sanfte Bewegung der Picturebox mithilfe der Pfeiltasten bewerkstelligen (ähnlich wie in Jump&Run Spielen dort bewegt sich der Charakter ja auch geschmeidig), außerdem soll die Bewegung beschleunigt werden d.h. je länger ich bsp. die linke Pfeiltaste drücke, desto schneller soll die Picturebox sich bewegen. Natürlich soll die maximale Geschwindigkeit auch begrenzt werden.

    Was fehlt mir? Ein großer Nachteil der aktuellen Implementierung ist der Übergang der Tasten, ich muss immer die gehaltene Taste loslassen, um die Richtung zu ändern. Außerdem sieht der Bewegungsablauf noch nicht sanft genug aus.

    Fehlt etwas an Informationen? Ist einigermaßen klar geworden, was ich vorhabe?

    Bilder
    • Bewegung.gif

      152,64 kB, 814×437, 124 mal angesehen
    Dateien

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „VB.neter0101“ ()

    Um eine konstante Bewegung zu haben, brauchst du eine konstante Geschwindigkeit. Für diese brauchst du eine konstante Zeit. Berechne dir im Keydown/Keyup nur den aktuellen Richtungsvektor (Bewegungsrichtung) und nicht mehr. Dann nimmst du dir einen Timer (mit z.B. 10ms Intervall), ein DateTime und ein TimeSpan Objekt. Das DateTime Objekt stellt den Zeitpunkt des letzten Timeraufrufs dar, nennen wir es lastUpdate. Das TimeSpan gibt dir die vergangene Zeit seit dem letzten Timeraufruf elapsedTime an. elapsedTime=DateTime.Now-lastUpdate
    Jetzt weißt du, unabhängig vom Timer Intervall, wieviel Zeit vergangen ist. Nun fehlt nur noch der Positionsvektor deiner Picturebox(GDI wäre schöner) und eine Geschwindigkeit in Pixel/s. Die aktuelle Position ist dann = velocity*direction*elapsedTime.TotalSeconds. Also Geschwindigkeit * Richtung * VergangeneZeit. Mit der Beschleunigung geht's analog. Diese gibst du an in Pixel/s^2 und errechnest damit die Geschwindigkeit. Geschwindigkeit=Beschleunigung*VergangeneZeitSeitStartenDerBeschleunigung
    @Gonger96 Jou.
    @VB.neter0101 Oder verstehe, was der @ErfinderDesRades und ich in den Links in Post #6 verzapft haben.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    @Gonger96 der Beitrag ist gut! Ein paar Anmerkungen

    Berechne dir im Keydown/Keyup nur den aktuellen Richtungsvektor


    Also nach dem Motto if(up) dann Y-Richtung = (+1), if(down) dann Y-Richtung = (-1), ebenso für X, passt das ?
    Zweitens warum wird bei Keydown/Keyup keine größere Berechnung an der Stelle gemacht?

    Geschwindigkeit * Richtung * VergangeneZeit


    Wird das dann nicht eine ganz schön große Zahl aufgrund "VergangeneZeit".

    Geschwindigkeit=Beschleunigung*VergangeneZeitSeitStartenDerBeschleunigung


    Für die Beschleunigung könnte man dann einen konstanten Wert nehmen, oder?
    @VB.neter0101 Das ganze ist elementar einfach, Du solltest Dir mal dir verlinkten Beispiele ansehen.
    Die große Zahl wird gar nicht so groß, da Du alles etappenweise machst und die History niemanden interessiert.
    Klar kannst Du die Beschleunigung konstant machen, versuche aber, sie variabel zu machen, denn von variabel nach konstant zu wechseln ist einfach, anders herum nicht so ganz.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    VB.neter0101 schrieb:

    Für die Beschleunigung könnte man dann einen konstanten Wert nehmen, oder?
    keine gute Idee - weil dann bewegt sich der Körper immer in dieselbe Richtung und wird dabei immer schneller.
    Auf dein Proggi-Ansatz übertragen wird deine Picturebox in kürzester Zeit aus dem Form herausgelaufen sein (oder am rechten Rand kleben - je nachdem).

    Mach dir vor allem klar, dass es hier um Vektor-Rechnung geht!
    Beschleunigung und Geschwindigkeit habem jeweils eine Richtung!

    Ein Auto bremsen ist eine Beschleunigung entgegen der Fahrtrichtung.
    Ein Auto um die Kurve bewegen ist eine Beschleunigung im rechten Winkel zur Fahrtrichtung.

    (und wenn später Masse hinzukommt, dann kommt auch Kraft hinzu - erstere ist kein Vektor, letztere aber)

    Lies die Physik dazu in iwelchen Büchern nach, oder auf Wikipedia.
    • Ohne Verständnis der Physik wird das nix
    • Und ohne Vektorrechnung auch nicht.
    • Und ohne Datenmodell auch nicht - siehe post#5

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Mein Problem ist eher die Umsetzung als die Mathematik, das macht es für mich sehr schwer... Z.b. dein Stichwort Vektorrechnung, wenn ich das höre, habe ich sofort einige Begriffe im Kopf und auch die dazugehörigen Berechnungen, aber wie und wo ich das jetzt genau anwenden kann, ist für mich relativ schwer (gut Abstand Punkt Ebene, ..., etc, das ist klar von der Anwendung, mein Wissen beschränkt sich hier eher auf die Theorie (wie man vllt. merkt...))

    Aber darum hab ich mir ja dieses Projekt ausgesucht, ich wollte das einfach mal anwenden/üben, ich werfe auch nochmal einen genaueren Blick in die Beispiele, einfach weills interessant ist.

    @Gonger96, @RodFromGermany @ErfinderDesRades wirklich nochmal vielen Dank für die Hilfe hierbei!

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „VB.neter0101“ ()

    VB.neter0101 schrieb:

    Also nach dem Motto if(up) dann Y-Richtung = (+1), if(down) dann Y-Richtung = (-1), ebenso für X, passt das ?

    Ja ganz genau. Nimm dir einen Vector, das Framework hat diese Klasse übrigens bereits (System.Windows.Vector ggf. Verweis auf WindowsBase erforderlich), und addiere auf dessen X/Y-Properties jeweils +1 oder -1 je nach gedrückter Taste. Am Ende normalisierst du den Vector. Drückt man dann Up hat man [0, -1], Down [0, 1], Up&Down [0, 0], Right&Down [sqrt(2), sqrt(2)] etc. Hier kann dir GetAsyncKeystate helfen.

    VB.neter0101 schrieb:

    Zweitens warum wird bei Keydown/Keyup keine größere Berechnung an der Stelle gemacht?

    Weil der Keydown unregelmäßig kommt. Beim ersten Tastenanschlag sofort, dann eine Pause bevor dieses Repeatbehaviour kommt. Das ist meines Erachtens für eine regelmäßige Bewegung ungeignet.
    @Gonger96 danke für die Antwort. Mit GetAsyncKeystate hab ich schon mal rumgespielt, das hat spaß gemacht! Hatte ich auch vor das noch zu nutzen. Vllt. noch zu meiner weiteren Planung (weil das hilfreich sein könnte), ich habe vor später damit den Windows Cursor zu positionieren, daher will ich das so puristisch wie möglich halten, die Picturebox ist nur als Testzweck auserkoren worden, um diese Bewegungen später auf den Cursor zu übertragen.

    VB.neter0101 schrieb:

    GetAsyncKeystate
    fragt nur ab, wenn der Ablauf da gerade vorbei kommt, also bei Button-Click mit gedrückten Tasten oder in einer Timer-Tick.
    Ich nutze das, um z.B. beim Speichern den SaveFileDialog zu umgehen.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!
    Guten Tag zusammen,

    ich fasse mal meinen aktuellen Stand zusammen. Ich habe jetzt eine gleichmäßig beschleunigte Bewegung, die allerdings bisher manuell über einen Button gesteuert wird. Wie ich zuvor schon bekannt gegeben habe, möchte ich das Ganze auf Tastaturanschläge (Tastenbetätigung, mit zunehmender Zeit soll etwa die Bewegung beschleunigt werden...) reagieren lassen, z.B. über die Pfeiltasten.

    Ich muss sagen, ich habe mich dieser Thematik jetzt erstmal rein mathematisch genähert, weil die Implementierung für mich viel schwieriger ist. Also was haben wir?

    Zuerst ist bekannt, dass
    $F = m\cdot a$
    ist, die Kraft ist gleich der Beschleunigung multipliziert mit einer Masse. Es stellt sich hier dann die Frage nach den entsprechenden Größen, aber das kann auch zunächst vernachlässigt werden und in der Implementierung herausgefunden werden...

    Außerdem ist
    $\vec{a}(t) = \dot{\vec{v}}(t) = \ddot{\vec{x}}(t)$
    . Das bedeutet
    $\frac{d^2x}{dt^2} = \ddot x = a = const.$
    . Es folgt hieraus ein DGL System zweiter Ordnung. Hierbei kann man auch folgende Angaben machen
    $v(t) = \frac{d}{dx}x(t)$
    ,
    $a(t) = \frac{d}{dt}v(t)$
    (Beschleunigung ist Geschw. Änderung
    $\Delta v$
    in Zeitintervall
    $\Delta t$
    , Geschw. Weg
    $\Delta s$
    der in Zeitintervall
    $\Delta t$
    zurückgelegt wird). Das ist nichts weiteres als die vorherige Formel nicht als Vektor, aber als DGL erster Ordnung.

    Diese DGLs habe ich nun mithilfe des expliziten Eulerverfahrens gelöst, dessen allgemeiner Ansatz ist:
    $y_{n+1} = y_{n} + f(x_n, y_n)\cdot h$
    . Das
    $h$
    ist hierbei die Schrittweite, die auch möglichst klein sein sollte, für eine gute Näherung. Kurz zum Euler Verfahren, hier gibt es unterschiedliche Möglichkeiten die Auflösung des Verfahrens zu verbessern, kleinere Schritte oder selbst das Verfahren zu Wechseln z.B. Runge Kutta oder implizites Euler Verfahren. Das nur am Rande. Die mit dem Euler Verfahren gelösten Gleichungen lauten dann in der Endfassung:
    $v_{n+1} = v_{n} + a_{n}\Delta t$
    für die Geschwindigkeit und
    $x_{n+1} = x_{n} + v_{n}\Delta t$
    für die Position. Des weiteren ist
    $a = \frac{F}{m}$
    .

    Ich habe mir dann in C# die Variablen time, mass, force, x_pos, velocity, dt definiert. In meine Form habe ich dann einen Timer und Button gezogen, wobei der Timer ein Intervall von 50 aufweist. Den Button benutze ich, um den Timer zu starten und die Zeit zu simulieren.

    Der Code:

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Drawing;
    6. using System.Linq;
    7. using System.Text;
    8. using System.Threading.Tasks;
    9. using System.Windows.Forms;
    10. namespace Beschl
    11. {
    12. public partial class Form1 : Form
    13. {
    14. public Form1()
    15. {
    16. InitializeComponent();
    17. }
    18. static double time = 0;
    19. double mass = 1;
    20. double force = 5;
    21. double x_pos;
    22. double velocity = 0.0;
    23. double dt = 0.1;
    24. private void button1_Click(object sender, EventArgs e)
    25. {
    26. x_pos = pictureBox1.Location.X;
    27. timer1.Enabled = true;
    28. timer1.Start();
    29. }
    30. private void timer1_Tick(object sender, EventArgs e)
    31. {
    32. if (time < 20.0)
    33. {
    34. //MessageBox.Show("" + x_pos);
    35. x_pos = x_pos + velocity * dt;
    36. velocity = velocity + (force / mass) * dt;
    37. pictureBox1.Location = new Point((int)x_pos, this.pictureBox1.Location.Y);
    38. time = time + dt;
    39. //Debug.WriteLine();
    40. }
    41. else
    42. {
    43. timer1.Stop();
    44. timer1.Enabled = false;
    45. }
    46. }
    47. }
    48. }


    Das Ergebnis:



    Fragen:
    1.) Was meint Ihr?
    2.) Ich finde, dass das noch sehr ruckelig aussieht, ist das nur Einbildung oder ist das wirklich so?
    3.) Was würdet ihr verbessern?
    Bilder
    • BewegungErgebnis.gif

      47,39 kB, 1.391×233, 73 mal angesehen

    Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von „VB.neter0101“ ()

    VB.neter0101 schrieb:

    Warum funktionieren die Formeln nicht?
    Woran machst Du das fest?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!