Spiele Programmierung - Neue Map anzeigen lassen

  • VB.NET

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

    Spiele Programmierung - Neue Map anzeigen lassen

    Das Problem hierbei ist bestimmt simple :) aber mit Spiele Programmierung habe ich seit vorgestern nichts am Hut gehabt ^^

    So mein Code fürs laufen ist sehr simple und da liegt auch schon das Problem.
    Zwar verändert sich die PictureBox (Player) aber ohne Zeit Verzögerung (also er ist sofort am Ziel)
    Hoffe jemand versteht das ohne "Verzögerung" also ohne dass die PictureBox "läuft".

    Quellcode

    1. Public Delegate Sub KeyEventHandler(ByVal sender As Object, ByVal e As KeyEventArgs)
    2. Private Sub Form1_MouseClick(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles Me.MouseClick
    3. PictureBox1.Location = MousePosition
    4. End Sub




    Dann noch eine Frage:

    Wie kann ich es, wenn der Player (PictureBox) sich oben, links, rechts, unten an der Form ist eine neue Karte "zeichnen"?
    Und wie kann ich das anzeigen? Einfach neues Background Image setzen? (sry soll erst nochmal simple sein, desswegen Background Image (die Kollisions Überprüfung wird noch iwann reinkommen jetzt soll es erstmal nur das bewegen und neu zeichnen Funktionieren ;) ) )

    Danke für kommende Antworten

    *Topic verschoben*

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

    du willst ja, dass der player quasie schrittweise zu seinem ziel geht. du musst den weg, den er zurücklegen soll also "stückeln", z.B.

    er soll pro sekunde 1 meter gehen
    1 meter sind auf deiner map 100 pixel
    damit ein flüssiges bild entsteht muss die animation ca. 25 frames/sekunde haben
    daraus ergibt sich, dass der player alle 40 milisekunden 4 pixel zurücklegen muss...

    du siehst, dein erstes problem ist nun, wie bekomme ich das mit der zeit hin? die antwort ist ein einfacher timer mit dem entsprechendem interval...

    allerdings rate ich dir dazu dich näher mit GDI zu befassen als controls "herumschwirren" zu lassen...

    lg


    EDIT: um dir bei dem "stückeln" etwas weiterzuhelfen
    du erinnerst dich ja sicher noch an den "satz des pythagoras"? den wirst du brauchen um die distans zwischen den beiden punkten (start und ziel) herauszufinden. Dann kannst du ganz leicht berechnen in wieviele stücke du die linie teilen musst, du berechnest die einzelnen punkte, schreibst die werte in einen array und lässt ihn dann punkt für punkt abarbeiten...





    Wie kann ich es, wenn der Player (PictureBox) sich oben, links, rechts, unten an der Form ist eine neue Karte "zeichnen"?
    Und wie kann ich das anzeigen? Einfach neues Background Image setzen? (sry soll erst nochmal simple sein, desswegen Background Image (die Kollisions Überprüfung wird noch iwann reinkommen jetzt soll es erstmal nur das bewegen und neu zeichnen Funktionieren ;) ) )



    wenn du die map im rpg-maker stil aufbaust hättest du das problem bei gdi auch nicht. die spielfigur immer in der mitte des bildschirms und die map bewegt sich^^ es würde ja ziehmlich doof aussehen, wenn man den oberen bildschirmrand erreicht hat plötzlich eine neue hintergrund-map geladen wird und die spielerfigur irgendwo unten weiterläuft...

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

    lol, warum so kompliziert? :D
    Prüfe einfach, ob die Zielposition X größer ist als die aktuelle Position X. Wenn ja, die aktuelle Position X um 1 Pixel erhöhen. Wenn die aktuelle Position kleiner ist, dementsprechend 1 Pixel abziehen. Genau das gleiche machst du auch mit der Y Achse.

    VB.NET-Quellcode

    1. 'X Position anpassen
    2. If newPos.X > actPos.X Then
    3. actPos.X += 1
    4. ElseIf newPos.X < actPos.X
    5. actPos.X -= 1
    6. End If
    7. 'Das selbe auch für die Y Achse
    8. If newPos.Y > actPos.Y Then
    9. actPos.Y += 1
    10. ElseIf newPos.X < actPos.X
    11. actPos.Y -= 1
    12. End If

    Und ansonsten mache das ganze unbedingt mit GDI+ oder XNA!
    MfG TheoTechnic
    PS: Will ja keine Eigenwerbung machen, du kannst aber mal in meinen Blog (siehe Siggnatur) schauen, da geht es auch solche Sachen ;)

    @TheoTechnic

    erstell mal auf diese art eine animation, sie wird sehr "bescheiden" aussehen... der spieler würde unregelmäßig schnell gehen!

    wenn er einfach nur nach rechts gehen würde hätte er eine geschwindigkeit von 1 pixel pro durchlauf. wäre der pfad um 45 grad geneigt hätte er eine geschwindigkeit von 1,41 pixel pro durchlauf!
    40% schneller als auf einem horizontalen oder vertikalen pfad... und das sieht man


    deinen blog werde ich mir aber mal ansehen, vllt habe ich ja unrecht^^

    Naja das mit den Firmen Lizensen war nur ne Schnapps Idee und naja bissln Geld (was sehr sehr unwahrscheinlich ist xD) verdienen.

    Naja was ist besser für ein RPG

    XNA (soll angeblich schneller sein, aber ich habe jetzt da nur 3D Spiele gesehen nur wenige 2D desswegen frag ich
    oder
    GDI

    Und was ist schneller zu erlernen?
    Naja ich will jetzt mal nichts hören von "lerne C++, ist besser für Spieleprogrammierung" (ist es auch aber naja ich will lieber bei VB 2008 bleiben;))

    Downloade mir gerade XNA SKD aber ich will mal eure Meinung hören

    mit xna habe ich noch garnichts am hut gehabt, kann aber sagen, dass es sehr wohl möglich ist mit GDI ein RPG oder ähnliches zu erstellen. es ist eigentlich sehr einfach zu erlernen und das beste - es ist schon teil von vb.net, du brauchst also keine zusätzlichen libs oder ähnliches..

    hier mal ein kleines video von meinem "RPG Maker"..das teil hab ich garnichtmehr weiterentwickelt, war eins dieser 2 stunden projekte...
    youtube.com/watch?v=FQZM4TlcoZk

    Nice und noch ne frage

    Angenommen ich würde GDI nehmen:

    Ruckelt es (bei größeren Spielen mit vielen Objekten (PictureBoxen etc....))?

    // Edit
    wo kann man deinen maker downloaden oder ist er noch nicht weiterentwickelt?
    Würde micht mal interessieren

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

    Also, du hast da scheinbar etwas nicht ganz verstanden:

    GDI ist eine Technik, Grafiken darzustellen, OHNE PictureBoxen verwenden zu müssen. Das läuft so gut wie ALLES im Programmcode ab, ist aber, wenn ein mal begriffen, sehr einfach. Tutorials findest du darüber übrigens hier im Board als auch sonst überall im Netz zur Genüge.

    Außerdem ja, das Zeichnen mit GDI ist an sich ganz gut, bei vielen Operationen allerdings schnell ruckelig. Es kommt auf den Programmierstil an: Programmierst du schlecht, können dir schon 10 Zeichnungen/Frame die Welt schwer machen. Programmierst du gut, kannst du weit mehr als 100 Objekte/Frame darstellen lassen. Du musst dich eben mit der Materie auseinandersetzen.

    Ich empfehle außerdem die Verwendung von (Mnaged) DirectX (Direct3D), wenn es ein wirklich großes Spiel werden sollte. Von XNA halte ich wenig, da ich persönlich keine Lust habe, mir ein weiteres Framework zu ziehen, das extra installiert werden muss (denn DirectX hat so gut wie jeder halbwegs gestandene Zocker auf der Platte ;))... Ist aber auch eben um einiges schwieriger.

    MfG,
    X-Zat / Momo

    das kommt darauf an, wieviele objekte und noch mehr darauf wie du programmierst!
    als erstes musst du aus dem picturebox-denken rauskommen^^ ich sage mal so, jedes control, jede picturebox, jeder button, einfach alles in vb.net wird mittels gdi gezeichnet. d.h. es ist unnötig eine picturebox zu gebrauchen, du zeichnest direkt auf die form.

    schreibe das mal in das me.paint ereignis:

    With e.Graphics
    .Clear(Color.White)
    .DrawLine(New Pen(Color.Red, 3), 0, 0, 200, 200)
    End With

    schon hast du etwas auf die form gezeichnet!

    da die rpg spiele ja in dieser block-grafik gezeichnet werden entsteht recht wenig rechenaufwand und es wird denke mal nicht ruckeln.

    bevor du anfängst rate ich dir dich weiter mit GDI zu beschäftigen, mit mehrdimensionalen arrays und eigenen klassen! die wirst du auf jeden fall brauchen um kein gigantischen codesalat zu erhalten...

    das damalige projekt hab ich garnichtmehr. wie gesagt, hab 2h zum spaß dran geproggt und dann nicht mehr weitergemacht.. mal gucken was ich so auf die schnelle zaubern kann^^ lg

    Ja also DirectX habe ich auch schon die SDK (weil ich mal Sounds ins Programm machen wollte aber naja ^^ wenns schwieriger ist dann lass ich das lieber - Mhmmm was meinst du mit größeres Spiel also so wie ein 1 GB Spiel or meinst du da schon unter 500 MB Spiele?)
    XNA habe ich auch abgebrochen weil 40 Minuten Downloadzeit und dann noch Installations Zeit habe ich echt gesagt auch kein Bock

    Werde mir erst mal GDI ansehen dann werde ich mal versuchen (falls ich es wirklich "größer" machen will oder gar online lieber DirectX angucken)

    Danke, dass du mich verbessert hast (wegen PictureBoxen ;) wie gesagt, ich fange erst heute mit GDI an also jetzt grade sonst hab ich normal alles über Pics gemacht was auch lästig wird :) )

    Ja habe mein Edit ja auch durchgestrichen habe es eben überflogen ^^

    so, hab mal ein bisschen code rausgehauen^^ ultragrob und eigentlich nur als grundgerüst gedacht.
    keine ahnung ob er funktioniert (tut er sicherlich nciht, da fehlt noch jede menge)... er zeigt dir aber worauf du dich da einlässt

    befasse dich zuerst mal mit GDI, dann mit Arrays und eigenen klassen (propertys!), ...
    dann wird dir vieles klarer und dann wirst du es auch schaffen ein pokemonclon zu basteln xD


    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class Form1
    2. Dim Engine As New RPGEngine
    4. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
    6. End Sub
    8. Sub RenderTick()
    9. 'wird von einem timer ausgeführt, idealerweise ca. 25 mal pro sekunde.. bedenke, dass hier
    10. 'nur gezeichnet wird. die daten manimulieren sprich playerbewegungen berechnen und und und
    11. 'geschieht wo anders! wo, keine ahung, ebefalls dein problem^^
    12. Engine.Render(Me.CreateGraphics)
    13. End Sub
    18. End Class
    21. Public Class RPGEngine
    23. Public Map(,) As block
    24. Public PlayerPosition As Point = New Point(0, 0)
    25. Public ScreenSize As Point = New Point(10, 10) 'die bildschirmauflösung in blöcken (10x10 entspricht 500x500 pixel wenn 1 bock 50x50 pixel groß ist)
    27. Sub New()
    28. Map = New block(100, 100) {} 'erstellt eine map mit 100x100 blöcken ausmaß
    29. 'wie du die daten in die map bekommst... ist dein problem xD
    31. PlayerPosition = New Point(50, 50) 'er steht mitten auf der map^^
    32. End Sub
    34. Public Sub Render(ByVal gra As Graphics)
    35. 'gra wäre z.b. me.creategraphics um auf form1 zu zeichnen, es gibt auch panel1.creategraphics, etc
    37. 'der spieler ist in der mitte, also ist die obere linke kante der noch sichtbaren map
    38. 'um die halbe screensize vom spieler entfernt..
    39. Dim xFrom As Integer = PlayerPosition.X - CInt(ScreenSize.X / 2)
    40. Dim xTo As Integer = PlayerPosition.X + CInt(ScreenSize.X / 2)
    41. Dim yFrom As Integer = PlayerPosition.Y - CInt(ScreenSize.Y / 2)
    42. Dim yTo As Integer = PlayerPosition.Y + CInt(ScreenSize.Y / 2)
    44. gra.Clear(Color.Black) 'der bildschirm wird schwarz gefärbt
    46. For x As Integer = xFrom To xTo
    47. For y As Integer = yFrom To yTo
    48. 'jeder block wird auf den schwarzen bildschirm gezeichnet
    49. Map(x, y).RenderBlock(gra, New Point(x, y))
    50. Next
    51. Next
    53. 'das wars schon^^
    54. End Sub
    59. End Class
    62. Public Class block
    64. Public Ebene1 As New sprite 'boden
    65. Public Ebene2 As New sprite 'spieler-höhe
    66. Public Ebene3 As New sprite 'himmel
    68. Public Sub RenderBlock(ByVal gra As Graphics, ByVal loc As Point)
    70. Dim PixelLocX As Integer = loc.X * 50 'aus dem block-raster die pixelwerte berechnen
    71. Dim PixelLocY As Integer = loc.Y * 50 'aus dem block-raster die pixelwerte berechnen
    73. With gra
    74. 'hier werden die 3 ebenen gezeichnet..
    75. .DrawImage(Ebene1.Grafik, PixelLocX, PixelLocY, 50, 50)
    76. .DrawImage(Ebene2.Grafik, PixelLocX, PixelLocY, 50, 50)
    77. .DrawImage(Ebene3.Grafik, PixelLocX, PixelLocY, 50, 50)
    78. End With
    80. End Sub
    82. End Class
    84. Public Class sprite
    85. 'würde ich nciht so machen, da jede bitmap viel speicher wegnimmt
    86. 'besser in der RPGEngine einmal eine Palette mit allen "sprites" erstellen und mittels
    87. 'zahlenwerten darauf verweisen
    88. 'außerdem würde ich
    89. Public Grafik As Bitmap 'sind alle gleichgroß, z.b. 50x50 pixel
    90. Public Begehbar As Boolean = True 'kann der spieler das feld begehen, wenn er auf seiner ebene ist?
    92. End Class

    du meinst sicher das hier:

    VB.NET-Quellcode

    1. Private Sub Form1_Paint(ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles Me.Paint
    2. With e.Graphics
    3. .Clear(Color.White)
    4. .DrawLine(New Pen(Color.Red, 3), 0, 0, 200, 200)
    5. End With
    6. End Sub


    der sub wird immer aufgerufen wenn die form neu gezeichnet (oder teilweise neu gezeichnet) wird. diese "immer aufrufen" kommt durch das paint-event (zu sehen an dem handles me.paint).
    wenn du alles richtig machst sollte das innere der form weiß werden und einen roten strich enthalten.. nur mal so als kleine demonstration

    @X-Zat: Häng an die 100 nochmal zwei nullen dran, mit GDI sind locker 10.000 Objekte möglich.

    Zudem würde ich für ein RPG XNA nehmen.
    Der Code ist dadurch viel kürzer und m. M. nach einfacher zu managen, aber das ist wohl ansichtssache.

    Edit:

    Im Anhang ein Programm das mit hilfe von GDI 10.000 Tanks zeichnet (Animiert)
    Um alle Tanks zu sehen braucht man eine recht hoher Auflösung ^^

    WICHTIG Das Programm benötigt 2,3 GB RAM !!

    Leicht modifizierter Quellcode von Mangafreak1995
    Dateien

    • Tanks.exe

      (34,82 kB, 267 mal heruntergeladen, zuletzt: )

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

    FreakJNS schrieb:

    erstell mal auf diese art eine animation, sie wird sehr "bescheiden" aussehen... der spieler würde unregelmäßig schnell gehen!

    wenn er einfach nur nach rechts gehen würde hätte er eine geschwindigkeit von 1 pixel pro durchlauf. wäre der pfad um 45 grad geneigt hätte er eine geschwindigkeit von 1,41 pixel pro durchlauf!
    40% schneller als auf einem horizontalen oder vertikalen pfad... und das sieht man


    Ach so, ich bin davon ausgegangen, das er nur 90° Veränderungen brauch (sprich Pfeiltasten). Wenn er auch kleinere Schritte machen will, wird das ganze schon komplizierter ;)

    Also meinen Erfahrungen nach würde ich dir aufjeden Fall XNA empfehlen.
    Ich habe mit XNA einmal ein 2D "Mensch ärger dich nicht" programmiert und habe dafür etwa 2-3 Tage gebraucht. Das zweite Projekt, das ich mit XNA mit nem Kumpel angegangen bin war Bomberman 3D. Es war quasi eine komplette neu Entwicklung des alten Games. Es gab einen Map-Editor, man konnte ganz einfach von Tastatur auf XBOX - Kontroller umstellen usw..
    Vorteile von XNA sind meines erachtens nach aufjeden Fall, die schnelle und gleichzeitig komfortable Entwicklung. Dazu hast du so gut wie keine Abstürze & es läuft verdammt flüssig.
    Kanns nur wärmstens empfehlen, sage aber nicht, dass es mit GDI nicht auch gehen würde.

    lg

Facebook
Telefonspende