Gdi+ und oder Objekte

  • VB.NET

Es gibt 21 Antworten in diesem Thema. Der letzte Beitrag () ist von Eistee.

    Gdi+ und oder Objekte

    Hallo zusammen.Ich habe mich mit diesem Abschnitt noch nicht befasst und bin daher Neuling.Vl habt ihr ja Tipps Tricks oder Hilfe zu folgendem:

    Wie kann ich zB für gdi+ Objekte erstellen ; diese über den Bildschirm bewegen und wieder zerstören/Kollision prüfen?

    Wichtig wäre also das die Koordinaten sowie größe farbe etc beinhaltet sind.

    Wie nennt man diese Objekte,wonach muss ich googeln?

    Als Beispiel gibt es das Spiel Dots im showroom,wenn es euch weiter hilft.

    Hier im Tutorial bereich gab es mal ein Tutorial zu GDI+ soviel ich weiss

    Du solltest wohl einfach mal damit beginnen VB.NET zu lernen.
    Es würde schon reichen wenn Du dir das kleine Gelileo-Buch zu Gemüte führen würdest.
    Es muss ja nicht unbedingt das 1.000+ Seiten starke MS-Buch sein.
    (Im Gelileo-Buch werden genau die Grundlagen angesprochen, welche Du hier für brauchst).

    Hy hier ist ein sehr gutes Tutorial zu GDI+ [VB 2008] [Tutorial] GDI+

    für dein vorhaben müsstest du dir eine klasse erstellen gameObjects mit den Koordinaten danach eine List of gameObject erstellen
    und deren Position mit einem Timer neu Berechnen und neu zeichnen

    und im Tick element die Koordinate versetzen.

    VB.NET-Quellcode

    1. oX += 50 Nach links verschieben
    2. oX -=50 Nach rechts Verschieben

    eigentlich reicht hier eine Klasse und ein List(of DEINEKlasse). Fertig ;)
    Fertige GDI+ Objecte gibt es glaube ich noch nicht :P

    @Andy16823
    AHH bitte falls das ein Spiel werden soll benutze doch einen Gameloop das ist um einiges besser, da kannst du mir vertrauen da ich am Anfang auch alles per Timer gemacht habe :D
    MFG 0x426c61636b4e6574776f726b426974
    InOffical VB-Paradise IRC-Server
    webchat.freenode.net/
    Channel : ##vbparadise

    Das Tutorial havbe ich bereits gelesen meine ich. Könntest du das etwas genauer erläutern


    für dein vorhaben müsstest du dir eine klasse erstellen gameObjects mit den Koordinaten danach eine List of gameObject erstellen
    und deren Position mit einem Timer neu Berechnen und neu zeichnen

    Du erstellst dir eine Klasse in der du die eigeneschfaten die dein Spiel Objekt besitzen soll festlegst.

    • Größe
    • Weite
    • Position X
    • Position Y
    • Bild
    Danch erstellst du dir eine List of GameObject, nun erstellst du dir eine Neue Instanz der erstellten klasse

    VB.NET-Quellcode

    1. Dim o as new GameObject
    2. o.Width = 16
    3. o.Height=16
    4. o.PosX=0
    5. o.PosY=0
    6. o.Bild=My.Ressources.bild.png

    und fügst diese in deine Liste ein

    VB.NET-Quellcode

    1. myList.add(o)

    danach in einem Gameloop die Koordinaten erhöhen oder veringern.

    Ich hatte mal ein Beispiel für jemanden gemacht:

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private Sub Form1_KeyDown(sender As Object, e As KeyEventArgs) Handles Me.KeyDown
    3. Hauptcharakter.Move(e.KeyCode) 'Hauptcharakter kann sich bewegen
    4. Nebencharakter.Move(e.KeyCode) 'Nebencharakter kann sich bewegen
    5. Me.Invalidate()
    6. End Sub
    7. Private Hauptcharakter As New Figur(My.Resources._1231, New Point(50, 50)) 'Startposition; Figur1
    8. Private Nebencharakter As New Figur(My.Resources.Drache, New Point(25, 25)) 'Startposition; Figur2
    9. Private Sub Form1_Paint(sender As Object, e As PaintEventArgs) Handles Me.Paint
    10. Hauptcharakter.Draw(e.Graphics) 'Hauptcharakter zeichnen
    11. Nebencharakter.Draw(e.Graphics) 'Nebencharakter zeichnen
    12. End Sub
    13. Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    14. Me.DoubleBuffered = True
    15. End Sub
    16. End Class
    17. Public Class Figur
    18. Public Sub New(ByVal img As Image, ByVal rec As Point)
    19. _rec = rec
    20. _img = img
    21. End Sub
    22. 'Hier befinden sich die Eigenschaften der Figur
    23. Private _rec As Point
    24. Public ReadOnly Property Koordinaten As Point
    25. Get
    26. Return _rec
    27. End Get
    28. End Property
    29. Private _img As Image
    30. Public ReadOnly Property Bild As Image
    31. Get
    32. Return _img
    33. End Get
    34. End Property
    35. Public Sub Draw(ByVal g As Graphics)
    36. With g
    37. .DrawImage(_img, New Rectangle(_rec, New Size(_img.Width, _img.Height)))
    38. End With
    39. End Sub
    40. Public Sub Move(ByVal e As Keys)
    41. Select Case e
    42. Case Keys.A
    43. _rec.X -= 10
    44. Case Keys.W
    45. _rec.Y -= 10
    46. Case Keys.S
    47. _rec.Y += 10
    48. Case Keys.D
    49. _rec.X += 10
    50. End Select
    51. End Sub
    52. End Class

    Es wird dir Bereits schon jetzt klar sein das du auch die vom Frame bewegen musst mit deiner Figur ich habe gerade ein ausführliches Tutorial Geschrieben wie das geht. Vll schaltet es ja die Moderation in den nächsten minuten / Stunde Frei ;)

    Hallo,
    was hast du mit GDI+ vor?
    Ein Button-Control?
    Gut, dann ist's das Richtige.
    Willst du nun ein Spiel mit GDI+ versuchen . -Nicht sehr geeignet.


    Doch, da du wirklich nur auf deinen Rat hörst, geb ich dir bezüglich Kollisionserkennung und bewegen von Objekten Tipps.
    Du beginnst nicht sofort, indem du einen Rectangle deklarierst, sondern beginnst mit Klassen:

    VB.NET-Quellcode

    1. Public Class ObjectRec
    3. End Class


    Du hast eine Klasse Objects, indem sind Properties inne.

    Quellcode

    1. INT Location
    2. INT Height
    3. BOOL CollisionAble


    Dann hast du eine Klasse Main.
    In der wird gezeichnet, Position neu festgelegt und dem Ähnlichen.

    VB.NET-Quellcode

    1. Public Class Main
    3. End Class

    In diese kommt nun die Instanziierung

    VB.NET-Quellcode

    1. Public Class Main
    2. Private FirstObject As New ObjectRec(0,0,0,0)
    4. End Class

    Im ObjectRec wird nun ein Konstruktor gesetzt:

    VB.NET-Quellcode

    1. Public Class ObjectRec
    2. Public Sub New(Rec As Rectangle)
    3. End Sub
    4. Public Sub New(x As Integer,y As Integer,width As Integer,height As Integer)
    5. End Sub
    7. Public ReadyOnly Property X,Y,Width,Height As Integer
    8. Public Property Location() As ObjectRec
    9. Get
    10. Return New ObjectRec(Me.X,Me.Y)
    11. End Get
    12. Set(value As ObjectRec)
    13. Me.X = value.X
    14. Me.Y = value.Y
    15. End Set
    16. End Property
    18. Public Property Size() As ObjectRec
    19. Get
    20. Return New ObjectRec(Me.Width,Me.Height)
    21. End Get
    22. Set(value As ObjectRec)
    23. Me.Width = value.Width
    24. Me.Height = value.Height
    25. End Set
    26. End Property
    28. Public Property CollisionAble As Boolean 'Legt fest, ob dieses Rectangle kollisionfähig ist.
    29. Public Property IsCollided As Boolean 'Wird bei einer Kollision auf TRUE gesetzt.
    30. Public CollisionObjects As List(Of ObjectRec) ' Objekte, bei denen eine Kollision ausgelöst wird...
    31. Sub Collision()
    32. For Each collision In CollisionObjects
    33. If New Rectangle(Me.X,Me.Y,Me.Width,Me.Height).IntersectsWith(New Rectangle(collision.X,collision.Y,collision.Width,collision.Height))
    34. IsCollided = True
    35. Exit For
    36. Else
    37. IsCollided = False
    38. Next
    39. End Sub
    41. Public Function GetRec() As Rectangle
    42. If CollisionAble Then
    43. Collision
    44. End If
    45. Return New Rectangle(Me.X,Me.Y,Me.Width,Me.Height)
    46. End Sub
    49. End Class


    So die ObjectRec-Klasse wär soweit fertig.

    Die Main-Klasse kannst du dir ja dann selbst basteln.
    Wenn du Hilfe brauchst, sags.
    Gruß

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „NGE'o“ ()

    Dekompilier es doch einfach, ist sogar erlaubt. Dann kannst du sehen, wie es gemacht wurde und wie es auch richtig geht (Krissel kennt sich gut mit solchen Dingen aus).

    Hä?
    Dann geh lernen...
    Ich denk logisch.
    sein
    Setze einen Array/List von Rectangle, prüfe ob diese mit dem Player kollidieren, finde heraus welches Rectangle, mit dem Player kollidierte, und lösche dieses, beispielsweise mit

    VB.NET-Quellcode

    1. Array.Clear(rec(i))

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „NGE'o“ ()

    Eistee schrieb:

    Es würde schon reichen wenn Du dir das kleine Gelileo-Buch zu Gemüte führen würdest.
    Es muss ja nicht unbedingt das 1.000+ Seiten starke MS-Buch sein.
    Und prompt in die Sch... getreten:
    Galileio erstellt sich seine Graphics-Objekte mit Control.CreateGraphics - was ja bekanntermaßen ein Holzweg ist.

    Glaub mir: dieses Buch lesen (hingegen das Galileio-Openbook ist Mist)
    (Muss man ja nicht alles lesen - was man bereits weiß, kann man ja überblättern)

    @ErfinderDesRades: Eigentlich nicht.

    Das hätte er schon selbst gemerkt und hier im GDI+ Tutorial wird ihm gezeigt wie es richtig geht.
    Worum es aber eigentlich ging, wenn der TE sich nicht einmal das Galileo Buch ansieht, wird er das MS Buch erst recht nicht anfassen.
    Damit endet die fragerei nach wie funktioniert .FillRectangle erst recht nicht.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Eistee“ () aus folgendem Grund: Rechtschrei

    ErfinderDesRades schrieb:

    deine Einstellung, mit der du hier Fragen [...] beantwortest?

    Nein ist sie nicht, nur in diesem Fall hab ich das so eingeschätzt, das es besser für den TE wäre, wenn er sich wenigstens dieser Lekture zuwendet.
    Das mit dem "Das hätte er schon selbst gemerkt" war darauf bezogen, das der TE das Ziel hat ein Spiel zu erstellen, wobei er das mit der Performance schnell herrausgefunden (selbst gemerkt) hätte.
    Es ist ja auch nicht so das dieses GDI+ Problem noch nie angesprochen wurde und auch nicht in (fast) jedem GDI+ Thema / Tutorial erwähnt wird (In diesem Thema Beitrag Nr.4, ist ein Tutorial verlinkt).
    Dazu kommt noch (würde ich mal behaupten) das es nicht so schlimm ist, zu wissen was es eigentlich mit dem CreateGraphics auf sich hat.
    Es geht etwas Zeit flöten, Ja. Aber es ist ja nicht so, das niemand helfen, erklären oder sonst etwas machen würde.

    Wenn das Beispiel/die Technik aus dem Galileobuch, umgesetzt auf das eigene Spieleprojekt zu ruckeln beginnt, wird der TE bestimmt zuerst dannach suchen und xxxx treffer zum Thema (incl. Tutorial wie man es richtig macht) finden. Wenn das jetzt alles zu weit her geholt sein sollte, werde ich es das nächste mal überdenken und sein lassen. Dachte mir das eben nur so. Würde zumindest etwas selbstständigkeit in die Bude bringen.

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

    Eistee schrieb:

    Dazu kommt noch (würde ich mal behaupten) das es nicht so schlimm ist, zu wissen was es eigentlich mit dem CreateGraphics auf sich hat.
    Falsch!
    Das ist sehr schlimm, und du solltest selbst mal das richtige Buch lesen, oder zumindest ein kompetentes Tutorial.
    Die Performance ist nicht das Problem, wenn man in ein mit CreateGraphics erstelltes Graphics zeichnet.

    Das Problem ist, dass dieses Graphics nicht richtig im Darstellungs-Mechanismus von WinForms eingebunden ist, und das macht ganz wunderliche Effekte.
    Etwa Zeichnungen lassen sich wegwischen, oder beim Resizen wird die hinzugekommene Fläche nicht gezeichnet und so Scherze.