Bewegte Figur

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 27 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Bewegte Figur

    Guten Abend,

    ich würde ganz gerne eine sich bewegende Figur darstellen.
    Nur, was ist der beste Weg dahin?

    Hatte gedacht die Figur in emf zu erstellen, da ich mit CAD gut umgehen kann.

    Oder sollte man das alles aus der GDI machen? (Das ist aber sehr komplex, damit eine Figur zu Zeichnen)
    BMP/JPG (ist auch eine Möglichkeit :/ )

    Wollte einfach 3 Bilder immer nacheinander anzeigen. (jeweils für hoch, runter, links, rechts)

    Was meint Ihr? Was ist der beste Ansatz eine laufende Fugur darzustellen?

    kiter20
    "Mann" lernt mit seinen Projekten.

    Komplex ist GDI(+) eigentlich nicht. Es ist sehr einfach verständlich, wie ich finde.

    Ich würde auf eine GraphicsPath zurückgreifen. Oder aber du schreibst dir eine eigene Klasse dafür. Mit Bitmaps ist es natürlich auch möglich, wobei das dann eher eine starre Animation ist. Wie weit kennst du dich denn schon in GDI aus?

    LG


    Was hast du vor? Ein Spiel? In dem Fall bietet sich GDI+ NICHT an, denn es ist performance-technisch völlig am Arsch. Hier würde man dann OpenGL oder DirectX verwenden.
    Grüße
    "Life isn't about winning the race. Life is about finishing the race and how many people we can help finish the race." ~Marc Mero

    Nun bin ich also auch soweit: Keine VB-Fragen per PM! Es gibt hier ein Forum, verdammt!

    Ich denke mit GDI habe ich gute Grundkenntnisse. (Habe nen code um dxf einzulesen und nachzuzeichnen geschrieben.)
    Mit komplex meine ich die Figur an sich. Es ist einfacher eine Figur zu zeichnen, wenn man sofort sieht was man macht.



    Nikx schrieb:

    Ein Spiel?

    Ja.
    Aber ich denke die GDI reicht.
    Kein bewegter Hintergrund. Nur eine Figur die sich von einem Ort zum anderen bewegt . Sonst nur ein paar Objekte welche sich hin und her bewegen.
    Ich möchte mich auch nicht in OpenGL oder DirectX reinarbeiten.

    kiter20
    "Mann" lernt mit seinen Projekten.

    Da wuerde ich einfach ein Sprite-Sheet nehmen.

    z.B. Link.



    (Quick'n'Dirty)
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class Sprite
    3. Public Link As Image
    4. Public X, Y As Integer
    5. Public Index As Integer
    6. Public Runs As Boolean = False
    8. Public Enum Directions
    9. Left
    10. Right
    11. End Enum
    13. Public Direction As Directions = Directions.Left
    15. Public Sub New(ByVal x As Integer, ByVal y As Integer)
    16. Link = Image.FromFile("link.png")
    17. Me.X = x
    18. Me.Y = y
    19. End Sub
    21. Public Sub DrawTile(ByVal g As Graphics)
    22. Index += 1
    23. If Index > 6 Then
    24. Index = 0
    25. End If
    26. If Not Runs Then
    27. Index = 3
    28. End If
    29. Select Case Direction
    30. Case Directions.Left
    31. g.DrawImage(Link, New Rectangle(X, Y, 32, 48), New Rectangle(Index * 32, 0, 32, 48), GraphicsUnit.Pixel)
    32. Case Directions.Right
    33. g.DrawImage(Link, New Rectangle(X, Y, 32, 48), New Rectangle(Index * 32, 48, 32, 48), GraphicsUnit.Pixel)
    34. End Select
    35. Runs = False
    36. End Sub
    38. End Class

    And i think to myself... what a wonderfuL World!

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Eddy“ ()

    @Eddy du bist schon einen Schritt weiter.

    Mir geht es erst einmal um den Grundgedanken. JPG / BMP / EMF / GDI ?
    Mit was arbeitet man am besten ?

    sry Eddy, ich sollte rst lesen dann schreiben. "Sprite -Sheet" ist auch ein Weg.
    "Mann" lernt mit seinen Projekten.

    JPG und GDI sind erstmal zwei grundverschiedene Sachen. Klopp dir das bitte rein.
    JPG ist ein Bildformat, GDI ist eine Zeichenschnittstelle.

    Grüße
    "Life isn't about winning the race. Life is about finishing the race and how many people we can help finish the race." ~Marc Mero

    Nun bin ich also auch soweit: Keine VB-Fragen per PM! Es gibt hier ein Forum, verdammt!

    kiter20 schrieb:

    Mit was arbeitet man am besten ?


    Da du weder DirectX oder OpenGl nehmen willst, ist GDI schon eine Option, wenns nur eine kleinere Animation ist, wirds wohl reichen. WPF ist sicher auch eine gute alternative, aber wie gross da der Aufwand ist, kann ich nicht einschaetzen, das Resultat waere sicher schoener.
    And i think to myself... what a wonderfuL World!

    @Eddy Was hat denn WPF jetzt damit zu tun? Klar, für Animationen geeignet, aber fürs Zeichnen einzelner Abfolgen für Spiele ebenfalls Nonsens.

    Grüße
    "Life isn't about winning the race. Life is about finishing the race and how many people we can help finish the race." ~Marc Mero

    Nun bin ich also auch soweit: Keine VB-Fragen per PM! Es gibt hier ein Forum, verdammt!

    Wollte WPF nur nicht unerwaehnt lassen, aber kiter20 sagte auch:


    Kein bewegter Hintergrund. Nur eine Figur die sich von einem Ort zum anderen bewegt . Sonst nur ein paar Objekte welche sich hin und her bewegen.


    In diesem Rahmen wird man mit beiden Technologien, schon etwas nutzbares erschaffen koennen.
    And i think to myself... what a wonderfuL World!

    Es ist völlig unerheblich, in welchem Format oder mit welchem Programm du die Animation erstellst. So lange du es in deinem Programm einlesen kannst, kannst du das Männchen auch mit Word zeichnen wenn du lustig bist.

    @kiter20 Ich warne aber, die Sprite-Klasse von @Eddy ist totaler Mist.

    Grüße
    "Life isn't about winning the race. Life is about finishing the race and how many people we can help finish the race." ~Marc Mero

    Nun bin ich also auch soweit: Keine VB-Fragen per PM! Es gibt hier ein Forum, verdammt!

    Also ich hab ein paar Standard-Kriterien für bewegliche OwnerDraw-Figuren:
    1. muss sich jederzeit neu zeichnen können
    2. muss unabhängig davon jederzeit seine Bounds angeben können - das umschließende Rechteck der Figur
    3. muss natürlich eine bewegliche Positions-Angabe bereitstellen
    Könnte man glatt als abstrakte Klasse formulieren, oder als Interface - wäre vlt. keine schlechte Idee:

    VB.NET-Quellcode

    1. Public Interface IOwnerDrawFigure
    2. ''' <summary> der Bereich des Controls, den diese Figur einnimmt. </summary>
    3. ''' <remarks> vor **und** nach Ortsveränderungen ist ctrl.Invalidate(figure.Bounds) aufzurufen, um gezieltes
    4. ''' Neuzeichnen beider Bereiche anzustossen: Wo sie vorher war (löschen), und wo sie anschließend ist. </remarks>
    5. ReadOnly Property Bounds As Rectangle
    6. Property Location As Point
    7. Sub Draw(g As Graphics)
    8. End Interface
    Deine Klasse erfüllt eiglich keinen dieser Punkte richtig.
    1) erfüllt sie, aber mit unvorhergesehenem Verhalten: Beim Zeichnen verändert sie selbst ihren Zustand, reproduziert ihre Darstellung also nicht konsistent.
    Das kann zu Darstellungsfehlern führen, etwa dass ein Bein beim Gehen sowohl als das vordere als auch als hinteres dargestellt ist.

    Also Zustandsänderungen müssen vom Zeichenvorgang getrennt sein. Denn nicht nur die Anwendung löst Neuzeichnen aus, sondern auch das OS stößt Neuzeichnen an, nämlich wenn Fenster anderer Anwendungen sich über deine Anwendung bewegt werden.
    In solchen Fällen muss die Figur ihre Darstellung exakt wieder herstellen wie sie war.

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

    Ok, hab das ein wenig verbessert. Mit einem Interface finde ich auch schuggelig, hab ich mal mit rein gemacht.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Enum Directions
    2. Up = 0
    3. Right = 1
    4. Down = 2
    5. Left = 3
    6. End Enum
    8. Public Class Sprite
    9. Implements ISprite
    11. Public X, Y, Width, Height, Speed As Integer
    13. Private Direction As Directions = Directions.Down
    14. Private Link As New Bitmap("Link.png")
    15. Private Walking As Boolean = False
    17. Public Sub Move(ByVal direction As Directions)
    18. Me.Direction = direction
    19. Walking = True
    20. Select Case direction
    21. Case Directions.Up
    22. Y -= Speed
    23. Case Directions.Right
    24. X += Speed
    25. Case Directions.Down
    26. Y += Speed
    27. Case Directions.Left
    28. X -= Speed
    29. End Select
    30. End Sub
    32. Public Sub New(ByVal x As Integer, ByVal y As Integer, ByVal width As Integer, ByVal height As Integer, Optional ByVal speed As Integer = 4)
    33. Me.X = x
    34. Me.Y = y
    35. Me.Width = width
    36. Me.Height = height
    37. Me.Speed = speed
    38. End Sub
    40. Public ReadOnly Property Bounds As System.Drawing.Rectangle Implements ISprite.Bounds
    41. Get
    42. Return New Rectangle(X, Y, Width, Height)
    43. End Get
    44. End Property
    46. Public Sub Draw(ByVal g As System.Drawing.Graphics) Implements ISprite.Draw
    47. Static xTileIndex As Integer = 3
    48. Dim yTileIndex As Integer = Direction
    49. xTileIndex += 1
    50. If xTileIndex > 6 Then
    51. xTileIndex = 0
    52. End If
    53. If Not Walking Then
    54. xTileIndex = 3
    55. End If
    56. Dim src As New Rectangle(xTileIndex * Width, yTileIndex * Height, Width, Height)
    57. Dim dest As Rectangle = Bounds
    58. g.DrawImage(Link, dest, src, GraphicsUnit.Pixel)
    59. Walking = False
    60. End Sub
    62. Public Property Location As System.Drawing.Point Implements ISprite.Location
    63. Get
    64. Return New Point(X, Y)
    65. End Get
    66. Set(ByVal value As System.Drawing.Point)
    67. X = value.X
    68. Y = value.Y
    69. End Set
    70. End Property
    72. End Class


    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Interface ISprite
    3. ReadOnly Property Bounds() As Rectangle
    4. Property Location() As Point
    5. Sub Draw(ByVal g As Graphics)
    7. End Interface


    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Threading
    2. Imports System.Runtime.InteropServices
    4. Public Class FrmGame
    6. <DllImport("user32.dll")> _
    7. Shared Function GetAsyncKeyState(ByVal vKey As System.Windows.Forms.Keys) As Short
    8. End Function
    10. Private Link As New Sprite(100, 100, 32, 48)
    11. Private StayAlive As Boolean = True
    12. Private Looop As Thread
    14. Private Sub Looping()
    15. While StayAlive
    16. Dim up, right, down, left As Boolean
    17. up = GetAsyncKeyState(Keys.Up) <> 0
    18. right = GetAsyncKeyState(Keys.Right) <> 0
    19. down = GetAsyncKeyState(Keys.Down) <> 0
    20. left = GetAsyncKeyState(Keys.Left) <> 0
    21. If right Then
    22. BeginInvoke(Sub() Render(Directions.Right))
    23. End If
    24. If left Then
    25. BeginInvoke(Sub() Render(Directions.Left))
    26. End If
    27. If up Then
    28. BeginInvoke(Sub() Render(Directions.Up))
    29. End If
    30. If down Then
    31. BeginInvoke(Sub() Render(Directions.Down))
    32. End If
    33. If Not (up Or right Or down Or left) Then
    34. BeginInvoke(Sub() Invalidate(Link.Bounds()))
    35. End If
    36. Thread.Sleep(35)
    37. End While
    38. End Sub
    40. Private Sub Render(ByVal direction As Directions)
    41. Dim r As Rectangle = Link.Bounds()
    42. Invalidate(r)
    43. Link.Move(direction)
    44. r = Link.Bounds()
    45. Invalidate(r)
    46. End Sub
    48. Private Sub FrmGame_FormClosing(ByVal sender As Object, ByVal e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
    49. StayAlive = False
    50. End Sub
    52. Private Sub FrmGame_Shown(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Shown
    53. Looop = New Thread(AddressOf Looping)
    54. Looop.Start()
    55. End Sub
    57. Private Sub FrmGame_Paint(ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles Me.Paint
    58. Link.Draw(e.Graphics)
    59. End Sub
    61. End Class


    Edit
    hab sogar noch einen kleinen Fehler in der Sub Render, da stimmte die Reihenfolge nicht.

    VB.NET-Quellcode

    1. [b][/b] Private Sub Render(ByVal direction As Directions)
    2. Dim r As Rectangle = Link.Bounds()
    3. Link.Move(direction)
    4. Invalidate(r)
    5. r = Link.Bounds()
    6. Invalidate(r)
    7. End Sub[b][/b]

    Dateien

    • SpriteSheets.zip

      (39,64 kB, 116 mal heruntergeladen, zuletzt: )
    And i think to myself... what a wonderfuL World!

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Eddy“ ()

    aber warum nennst du das Interface ISprite?
    Es kann alle möglichen ZeichenFiguren geben, eine SpriteSheet-Figur ist nur ein ganz spezieller Spezialfall davon.

    Und das mit dem Threading ist auch total komisch.
    Zieh doch einfach einen Timer aufs form, dann brauchst du weder Thread noch die Invoking-Umständlichkeit.

    Die benamung ist wirklich mehr als schlecht gewaehlt. Ein Timer haette es hier wirklich getan, war gedanklich schon dabei ein Gameloop rein zu machen, da habe ich immer mit festgelegter Framerate gearbeitet(mit GetTickCount Zeitabstaende gemessen), da sind Threads praktisch, einfach den Thead solange kein Update stattfinden soll schlafen legen(Loop mit Sleep(1)).
    And i think to myself... what a wonderfuL World!

Facebook
Telefonspende