Walljump mit fremder platformer Engine umsetzen

  • GM 8

  • Walljump mit fremder platformer Engine umsetzen

    Ich habe kürzlich eine nette Engine gefunden, welche eine super Kollisions-Abfrage hat. Credits gehen an Shaun Spalding.
    Das Problem ist jetzt, ich möchte einen Walljump einbauen, sodass man auch von der Wand abspringen kann.
    Ich komme aber mit der Engine nicht so wirklich klar und weiß nicht wie ich das umsetzen kann. Ein Versuch brachte mein Spieler "rutschend" in hohem Bogen über alle Wände.

    Create Event:
    Spoiler anzeigen

    GML-Quellcode

    1. grav = 0.8;
    2. hsp = 0;
    3. vsp = 0;
    4. jumpspeed = 12;
    5. movespeed = 4;

    Step Event:
    Spoiler anzeigen

    GML-Quellcode

    1. //smooth the camera
    2. camera_movement();
    4. //Get the player's input
    5. key_right = keyboard_check(vk_right);
    6. key_left = -keyboard_check(vk_left);
    7. key_jump = keyboard_check_pressed(vk_space);
    10. //React to inputs
    11. move = key_left + key_right;
    12. hsp = move * movespeed;
    13. if (vsp < 10) vsp += grav;
    16. if (place_meeting(x,y+1,obj_wall))
    17. {
    18. vsp = key_jump * -jumpspeed
    19. }
    22. //Horizontal Collision
    23. if (place_meeting(x+hsp,y,obj_wall))
    24. {
    25. while(!place_meeting(x+sign(hsp),y,obj_wall))
    26. {
    27. x += sign(hsp);
    28. }
    29. hsp = 0;
    30. }
    31. x += hsp;
    34. //Vertical Collision
    35. if (place_meeting(x,y+vsp,obj_wall))
    36. {
    37. while(!place_meeting(x,y+sign(vsp),obj_wall))
    38. {
    39. y += sign(vsp);
    40. }
    41. vsp = 0;
    42. }
    43. y += vsp;
    Alles anzeigen

  • Naja, du weißt ja, dass wenn links oder rechts vom Spieler eine Wand ist, und unter ihm kein Boden, ein Wall Jump ausgeführt werden kann. Und dann muss ja eigentlich nur die vspd und hspd gesetzt werden.

    GML-Quellcode

    1. // Wall Jump
    2. if((place_meeting(x + 1, y, obj_wall) ^ place_meeting(x - 1, y, obj_wall)) &! place_meeting(x, y + 1, obj_wall) && key_jump) {
    3. // Die vertikale Speed setzen wir hier auf die normale Sprunghöhe.
    4. vsp = -jumpspeed;
    5. // Wenn der Spieler rechts eine Wand trifft (x + 1), dann setzen wir die horizontale Speed auf -4. Wenn er links eine
    6. // Wand trifft (x - 1) auf 4, um ihn von der Wand abspringen zu lassen.
    7. hsp = place_meeting(x + 1, y, obj_wall) * -4 + place_meeting(x - 1, y, obj_wall) * 4;
    8. }

    Kann sein, dass der Code nicht oder nicht ganz funktioniert, ich habe ihn jetzt einfach hier im Post geschrieben. Es wäre trotzdem schöner dir zu helfen, wenn du uns deinen "Fehlversuch" zeigst und man darauf aufbauend eine Lösung findet. ;)

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von ghost ()

  • An sich schon mal ein super Ding, nur sollte ein Walljump nur von Wand zu Wand möglich sein.
    Jetzt kann man jedoch an einer Wand immer weiter nach oben springen.

    Zudem fällt der Walljump sehr schwer, da man die Tasten sofort drücken muss um einen Walljump auszuführen. Hoffe das ist verständlich.
    Der Spieler müsste ein wenig an der Wand "kleben" ähnlich wie bei SuperMeatBoy. Sodass man etwas mehr Zeit hat, den Sprung zu machen.
    Und es ist auch schwierig an Höhe zu gewinnen wenn man von Wand zu Wand springt.

    In folgendem Link wurde das ganze schon mal diskutiert. Allerdings in Englisch. Ich kann dem Thema leider nicht wirklich folgen. Vielleicht könnte es euch aber helfen, mir behilflich zu sein :)
    Link: gmc.yoyogames.com/index.php?showtopic=614107

    (Wenn sie fertig ist, würde ich hier die komplette Plattform Engine auch rein setzen)

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

  • Naja, du musst halt selbst mit den Werten spielen und den Teil mit der vertikalen Speed verschieben und bearbeiten. Das ist nicht schwer und erfordert eigentlich nur Fleiß.

    GML-Quellcode

    1. var stick;
    2. stick = false;
    4. // Wall Jump
    5. if((place_meeting(x + 1, y, obj_wall) ^ place_meeting(x - 1, y, obj_wall)) &! place_meeting(x, y + 1, obj_wall) && key_jump) {
    6. // Die vertikale Speed setzen wir hier auf die normale Sprunghöhe.
    7. vsp = -jumpspeed;
    8. // Wenn der Spieler rechts eine Wand trifft (x + 1), dann setzen wir die horizontale Speed auf -4. Wenn er links eine
    9. // Wand trifft (x - 1) auf 4, um ihn von der Wand abspringen zu lassen.
    10. hsp = place_meeting(x + 1, y, obj_wall) * movespeed + place_meeting(x - 1, y, obj_wall) * movespeed;
    11. stick = true;
    12. }
    14. //Gravity
    15. if(stick) {
    16. // Wenn der Spieler an der Wand klebt, soll er langsamer fallen
    17. if (vsp < 5) vsp += grav / 2;
    18. else vsp = 5;
    19. } else {
    20. // Wenn der Spieler nicht an der Wand klebt, soll er normal fallen
    21. if (vsp < 10) vsp += grav;
    22. }
    Alles anzeigen


    Das Problem, dass du einfach an der gleichen Wand hochspringen kannst liegt denke ich daran, dass die Bewegung keine Beschleunigung hat.

    GML-Quellcode

    1. hsp = move * movespeed;


    Hier müsste noch Beschleunigung rein. Also zum Beispiel so in der Art:

    GML-Quellcode

    1. if(hsp < move * movespeed) {
    2. hsp += acceleration;
    3. }
    4. if(hsp > move * movespeed) {
    5. hsp -= acceleration;
    6. }

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von ghost ()

  • @ghost Ja, mein Problem ist, dass ich nicht wirklich gut in Sachen Logik bin und mir deshalb so etwas sehr schwer fällt.
    Aber ich habe auch niemanden, der meine Ideen umsetzt und muss das daher alles selbst machen. Ich möchte mich natürlich dennoch bemühen :)

    Zu deinem Code, "acceleration" müsste ich ja nur durch einen beliebigen Wert ersetzen, oder?
    Jedenfalls funktioniert das nicht wirklich. Der Spieler bleibt jetzt nicht kleben, kann immer noch an einer Wand beliebig oft hinauf springen und die Sprunghöhe wird vermindert.

  • Ja dafür kannst du einsetzen was du willst. Ich habe es jetzt mal ausprobiert. Hier ist mein Kompletter Code:

    :event_create: Create
    Spoiler anzeigen

    GML-Quellcode

    1. grav = 0.8;
    2. hsp = 0;
    3. vsp = 0;
    4. jumpspeed = 12;
    5. movespeed = 4;
    6. acceleration = 0.75;


    :event_step: Step
    Spoiler anzeigen

    GML-Quellcode

    1. var stick;
    2. stick = false;
    4. //Get the player's input
    5. key_right = keyboard_check(vk_right);
    6. key_left = -keyboard_check(vk_left);
    7. key_jump = keyboard_check_pressed(vk_space);
    10. //React to inputs
    11. move = key_left + key_right;
    13. if(hsp < move * movespeed) {
    14. hsp += acceleration;
    15. }
    16. if(hsp > move * movespeed) {
    17. hsp -= acceleration;
    18. }
    21. if (place_meeting(x,y+1,obj_wall))
    22. {
    23. vsp = key_jump * -jumpspeed
    24. }
    27. //Horizontal Collision
    28. if (place_meeting(x+hsp,y,obj_wall))
    29. {
    30. while(!place_meeting(x+sign(hsp),y,obj_wall))
    31. {
    32. x += sign(hsp);
    33. }
    34. hsp = 0;
    35. }
    36. x += hsp;
    39. // Wall Jump
    40. if((place_meeting(x + 1, y, obj_wall) ^ place_meeting(x - 1, y, obj_wall)) &! place_meeting(x, y + 1, obj_wall)) {
    41. // Die vertikale Speed setzen wir hier auf die normale Sprunghöhe.
    42. if(key_jump) {
    43. vsp = -jumpspeed;
    44. // Wenn der Spieler rechts eine Wand trifft (x + 1), dann setzen wir die horizontale Speed auf -movespeed * 2. Wenn er links eine
    45. // Wand trifft (x - 1) auf movespeed * 2, um ihn von der Wand abspringen zu lassen.
    46. hsp = place_meeting(x + 1, y, obj_wall) * -movespeed * 2 + place_meeting(x - 1, y, obj_wall) * movespeed * 2;
    47. }
    48. stick = true;
    49. }
    52. //Gravity
    53. if(stick) {
    54. // Wenn der Spieler an der Wand klebt, soll er langsamer fallen
    55. if (vsp < 4) vsp += grav / 2;
    56. else vsp = 4;
    57. } else {
    58. // Wenn der Spieler nicht an der Wand klebt, soll er normal fallen
    59. if (vsp < 10) vsp += grav;
    60. }
    63. //Vertical Collision
    64. if (place_meeting(x,y+vsp,obj_wall))
    65. {
    66. while(!place_meeting(x,y+sign(vsp),obj_wall))
    67. {
    68. y += sign(vsp);
    69. }
    70. vsp = 0;
    71. }
    72. y += vsp;
    Alles anzeigen


    Ich hatte noch einen kleinen Fehler in der Zeile:

    GML-Quellcode

    1. if((place_meeting(x + 1, y, obj_wall) ^ place_meeting(x - 1, y, obj_wall)) &! place_meeting(x, y + 1, obj_wall) && key_jump) {


    Denn stick sollte auch auf true gesetzt werden, wenn der Spieler nicht die Sprungtaste (key_jump) drückt (ja, ich sollte den Code ausprobieren bevor ich ihn poste :pinch: ). Ansonsten hat das ganze jetzt auch viel mit dem ausprobieren der Werte zu tun. Zum Beispiel solltest mal schauen ob du anstatt (-) movespeed * 2 in Zeile 45 im Step Event nicht noch einen besseren Wert findest. Dieser bestimmt wie arg der Spieler horizontal von der Wand abgestoßen wird.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von ghost ()

  • Also mit dem Script "schmiert" er jetzt durchgehend nach links.

    :event_step: Step:
    Spoiler anzeigen

    GML-Quellcode

    1. //smooth the camera
    2. camera_movement();
    4. var stick;
    5. stick = false;
    7. //Get the player's input
    8. key_right = keyboard_check(vk_right);
    9. key_left = -keyboard_check(vk_left);
    10. key_jump = keyboard_check_pressed(vk_space);
    13. //React to inputs
    14. move = key_left + key_right;
    16. if(hsp < move * movespeed) {
    17. hsp += acceleration;
    18. }
    19. if(hsp > move * movespeed) {
    20. hsp -= acceleration;
    21. }
    24. if (place_meeting(x,y+1,obj_wall))
    25. {
    26. vsp = key_jump * -jumpspeed
    27. }
    31. // Wall Jump
    32. if((place_meeting(x + 1, y, obj_wall) ^ place_meeting(x - 1, y, obj_wall)) &! place_meeting(x, y + 1, obj_wall) && key_jump) {
    34. // Die vertikale Speed setzen wir hier auf die normale Sprunghöhe.
    35. if(key_jump) {
    36. vsp = -jumpspeed;
    37. // Wenn der Spieler rechts eine Wand trifft (x + 1), dann setzen wir die horizontale Speed auf -movespeed * 2. Wenn er links eine
    38. // Wand trifft (x - 1) auf movespeed * 2, um ihn von der Wand abspringen zu lassen.
    39. hsp = place_meeting(x + 1, y, obj_wall) * -movespeed * 2 + place_meeting(x - 1, y, obj_wall) * movespeed * 2;
    40. }
    41. stick = true;
    42. }
    45. //Gravity
    46. if(stick) {
    47. // Wenn der Spieler an der Wand klebt, soll er langsamer fallen
    48. if (vsp < 4) vsp += grav / 1.5;
    49. else vsp = 4;
    50. } else {
    51. // Wenn der Spieler nicht an der Wand klebt, soll er normal fallen
    52. if (vsp < 10) vsp += grav;
    53. }
    58. //Horizontal Collision
    59. if (place_meeting(x+hsp,y,obj_wall))
    60. {
    61. while(!place_meeting(x+sign(hsp),y,obj_wall))
    62. {
    63. x += sign(hsp);
    64. }
    65. hsp = 0;
    66. }
    67. x += hsp;
    70. //Vertical Collision
    71. if (place_meeting(x,y+vsp,obj_wall))
    72. {
    73. while(!place_meeting(x,y+sign(vsp),obj_wall))
    74. {
    75. y += sign(vsp);
    76. }
    77. vsp = 0;
    78. }
    79. y += vsp;
    Alles anzeigen

    Zudem denke ich, dass es besser wäre, dass der Spieler auf die Seite abspringt, in welche die Pfeiltaste gedrückt wird.
    Und er kann immernoch auf einer Wand hoch. Musst mal testen. Eigentlich passt fast alles, nur das von eben erwähnte und an sich finde ich die Steuerung recht schwer. Man kommt an einer Wand genauso schwer hoch wie wenn man von Wand zu Wand hoppt.
    Danke dir schon mal für die große Hilfe. Ich packe dich auf jeden Fall in die Credits! :)

  • Du hast die eine wichtige Zeile (bei dir 32) nicht geändert... :D

    Richtig muss es heißen:

    GML-Quellcode

    1. if((place_meeting(x + 1, y, obj_wall) ^ place_meeting(x - 1, y, obj_wall)) &! place_meeting(x, y + 1, obj_wall)) {


    Nicht:

    GML-Quellcode

    1. if((place_meeting(x + 1, y, obj_wall) ^ place_meeting(x - 1, y, obj_wall)) &! place_meeting(x, y + 1, obj_wall) && key_jump) {

  • Oops :D

    Ich muss mich auch nochmal korrigieren.
    Es ist, wenn man nach SuperMeatBoy geht, eigentlich ganz praktisch an einer Wand springen zu können.
    Hier eine nette SMB Engine. Leider keine GameMaker Datei.
    sandbox.yoyogames.com/games/184833-super-meat-boy-gm-mkii

    Aber da kann man sehr schön sehen wie ich das gerne umgesetzt hätte, was die Steuerung betrifft.
    Wir sind ja schon recht nah dran.

    Edit: Er rutscht immer noch nach links.

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

  • Lunatic447 schrieb:

    Oops :D

    Ich muss mich auch nochmal korrigieren.
    Es ist, wenn man nach SuperMeatBoy geht, eigentlich ganz praktisch an einer Wand springen zu können.
    Hier eine nette SMB Engine. Leider keine GameMaker Datei.
    sandbox.yoyogames.com/games/184833-super-meat-boy-gm-mkii

    Aber da kann man sehr schön sehen wie ich das gerne umgesetzt hätte, was die Steuerung betrifft.
    Wir sind ja schon recht nah dran.

    Edit: Er rutscht immer noch nach links.


    Du musst darauf achten das die acceleration durch die movespeed teilbar ist. Nimm als acceleration zum Beispiel einfach mal 0.5 oder 1, dann sollte er glaube ich nicht mehr einfach so "rutschen". Ich habe bei den Beispielwerten leider nicht darauf geachtet, hatte es selbst mit 1 getestet.

  • ghost schrieb:

    Du musst darauf achten das die acceleration durch die movespeed teilbar ist. Nimm als acceleration zum Beispiel einfach mal 0.5 oder 1, dann sollte er glaube ich nicht mehr einfach so "rutschen". Ich habe bei den Beispielwerten leider nicht darauf geachtet, hatte es selbst mit 1 getestet.


    Ok so geht es. Er rutscht nicht mehr.
    Jetzt fehlt mir aber noch die Möglichkeit die Sprungrichtung durch die Pfeiltasten zu bestimmen. Dann müsste es eigentlich alles passen.