Aufs falsche Pferd gesetzt?

VoidByte · 1. Juli 2016, 17:26

Hallo schon wieder ;D

Ich habe mir vor 2 Wochen GMS:Pro auf Steam gekauft, für satte 140€.
Getan habe ich das, weil ich unter anderem mein Geld mit dem Konzeptionieren von "Dingen" verdiene und leidenschaftlicher Zocker bin.
Will heißen, ich habe fertige Konzepte für 3 Spiele hier liegen und habe mich dann in einschlägigen Foren schlau gemacht, welche Engine am geeignetsten ist, diese Ideen auch mal in die Tat um zu setzen, da diese langsam Staub fangen.
Und die Antwort war praktisch einstimmig: "Für 2D Spiele nimm GMS".

Nun, viele viele Stunden von Tutorials in Wort und Bild später glaube ich, dass es ein Fehlkauf war.
Denn so wie es scheint, kann man mit GMS zwar eine Menge machen, mit entsprechendem Aufwand, aber der Aufwand ist vollkommen unverhältnismäßig zum Ergebnis.
Denn wenn man keinen Plattformer, kleine knobelspielchen oder Zelda-Japan-RPG like machen möchte, wirds offenbar sehr schnell zu einer Lebensaufgabe.

Konkret rede ich jetzt hier von Dingen, die eine Spiele-Engine meines achtens nach einfach mitbringen sollte. Wie einen Dialogeditor.. oder ein Basisverständnis für andere Perspektiven als "top down".
Nehmen wir beispielsweise mal die Dialoge. Ein Spieler möchte ein Gespräch mit einem NPC führen das wie ein echtes, Verzweigungen und multiple choice antworten hat.
In GMS scheint dafür ein Studium notwendig zu sein. Also alleine das ich für eine Textbox schon 50 Zeilen Code brauche ohne das Text drin steht is schon mal echt... Wahnsinn.
Das ganze wird dann noch garniert wenn man eben nicht einen "one-click Einzeiler" ausgeben lassen möchte, sondern ein komplettes Gespräch (alla Dragon Age:Origin, Drakensang oder Black Mirror).
Wenn die Entscheidungen die man in diesem Gespräch trifft, dann auch noch Auswirkungen auf die Spielwelt haben sollen, dann wirds vollends haarig.

Auch eine Point-and-Click Steuerung mit hover effekt (für Hotspots) unter der Maus entpuppt sich als Aufgabe für die man ein 5 Köpfiges Entwicklerteam, oder 2 Jahre Akkordarbeit braucht.
Ich komme aus der Web-Entwicklung, und da gibt es diesen Spagat auch. Man kann mit CSS3 und HTML5 Canvas eine Menge tolle Sachen machen. Aber wenn man dafür eine CSS file braucht die 150.000 Zeilen lang ist, nimmt man doch lieber ein animiertes gif.

Und mir scheint eben, dass es nicht umsonst so ist, dass man im Internet ausschließlich Japan-RPG tutorials findet im Zelda look oder eben Plattformer. Offenbar ist das dass einzige zu dem die Engine gedacht ist.
Alles was darüber hinaus geht ist mehr oder weniger praktisch komplett selbst-machen (was dann eben auch ganz ohne GMS-IDE gehen würde mit Ogre oder Irrlicht ). Und da versteh ich dann halt nicht ganz, wieso manche Menschen engines für eine engine schreiben.
Wenn ich jetzt ein Point-and-Click Adventure machen möchte würd ich ja Visionaire nutzen, und nicht GMS auf gedeih und verderb umformen, nur um die Grundfunktionen von Visionaire zu imitieren um DANN erst beginnen zu können das eigentliche Spiel
zu schreiben. Selbiges mit allem was 3D ist, wieso sollte ich jede einzelne 3D Berechnung händisch schreiben, statt einfach die CryEngine, UnrealEngine oder sogar Unity3D zu nehmen. Und zuguterletzt.. würde ich ein Rollenspiel im Japan-Stile benötigen hätte ich mich für RPGMaker entschieden. Da dieser alle Funktionen für ein RPG mitbringt.

Also das hier soll kein Auskotzen sein.. und bevor der erste mit "Hau doch ab, wenns dir nich gefällt!" kommt, hier die Intention für diesen Thread:
Hab ich aufs falsche Pferd gesetzt mit dem Kauf? Täusch ich mich und alles sieht schlimmer aus als es ist? Und wieso macht ihr das (also, Grundfunktionen nachprogrammieren) und was motiviert euch daran?
Oder seit ihr wie ich auch erst nach dem kauf auf die Ernüchterung gestoßen und versucht den Preis jetzt durch Fleiß zu rechtfertigen?
Es würde mich einfach mal interessieren wieso das Produkt so beliebt ist und so viele Fans hat, wo doch die Out-Of-The-Box Funktionsweise so extrem beschränkt ist (oder mir vorkommt. Ich hoffe ja immernoch das ich mich irre.)

Liebe Grüße, VB

Rhazul · 1. Juli 2016, 17:59

Ich sags direkt - Hart aber fair - Wenn man programmieren innerhalb von ein paar Tagen lernen will und keine Geduld hat, dann ist das ganze einfach nichts für einen. Dein Text ist eigentlich ein negativ von dem was ich mit dem GM an Erfahrung gesammelt habe, denn es geht alles viel schneller als in anderen Sprachen. Geb in C++ mal einen Farbigen Bildschirm mit Text aus, dann weißt du was umständlich heißt. Im GM einfach nur

GML-Quellcode

draw_clear(c_green);
draw_text (10,10,"Hello World!");

Man muss halt meines Erachtens schon Programmieren lernen oder sich wenigstens mit den Grundlagen vertraut machen. Und das geht nicht in 2 Wochen, erste Erfolge evtl eher nach 2 Monaten. Vorgebackene Sachen wie Dialoge gibt es nicht, da sowas einfach immer aufs spiel differenziert angepasst werden muss um gut zu sein. Wenn ich mich ransetze dann frage ich mich nicht warum es keine Dialogboxen gibt, dann setz ich mich einfach dran und erstelle sie nach meinen Wünschen. Das ist auch super einfach, sofern es nicht schon an den Grundlagen scheitert. & Wenn es mal etwas gibt was man selbst nicht packt, kann man sich mit vielen Extensions versorgen da viel Arbeit schon von anderen Entwicklern getan wurde. Mit dem GM lässt sich mittlerweile so gut wie alles umsetzen, Komplexere Probleme sind aber natürlich aufwändiger, man kann nicht davon ausgehhen das einem In der Programmierwelt alles ins Schoß gelegt wird. Selbst ansehliche 3d Spiele lassen sich erstellen dank Shadern etc, nur muss man begreifen das es ein langer Weg zu einem Fertigen Spiel wird. Und wenn du einmal bspw. deine Dialoge Programmiert hast kannst du sie auch in jedem nächsten Projekt verwenden. Mit mehr Übung geht es irgendwann sehr leicht da man sich auskent und weiß welche Funktionen man zur Lösung eines Problems in Betracht ziehen kann.
Als Fazit würde ich ziehen, dass du deine Erwartungen runterschrauben solltest. Gibt es "alternativen" welche mehr Standardfunktionalität aufweisen? Ja - allerdings wird man damit aber auch nie etwas wirklich gescheites auf die Beine stellen können, da die Funktionalität eingeschränkt ist.
Ich hoffe allerdings du bleibst trotzdem motiviert und nutzt bei Fragen das Forum.

Husi012 · 1. Juli 2016, 18:06

Klar bietet GM nicht so viele Funktionen, die zB. eine NPC-Sprachbox anzeigt, wäre auch ganz nett, kann man sich aber natürlich alles selber erstellen.
Wenn man dann nicht die Engine von anderen GM Games kopiert, hast du immer ein etwas anderes Design drinne, was meiner Meinung nach besser ist, als wenn du tausende Spiele mit fast selben Layout hast.
Und GM ist auch das Gegenteil von eingeschränkt, da du nahezu alles machen kannst (so lange der Computer durch GM explodieren soll). Und wenn kann man dann auch noch in C oder C++ Dlls schreiben, die noch mehr Funktionsumfang bietet usw.
Wenn man erst mal eine Sprachbox fertig hat, kann man die so verpacken, dass du die sehr einfach in anderen Spielen von dir direkt wieder implementieren kannst und hast dort keine Probleme mehr damit.

Wenn du dir hohe Programmiersprachen wie Java,C,C++,C# oder sogar Assembler anschaust, wird das ganze natürlich noch schwerer. Sind aber auch nicht extra für Spiele gemacht.
Hier und in anderen Foren gibt es viele Tutorials und kostenlose Engines die dir auch das Leben erleichtern (auch wie oben erwähnt, dass man das Design nicht zu stark übernehmen sollte)
Auch ich habe zwei gute Tutorials geschrieben (If-Bedingungen,Schleifen) und andere wie @Sorm oder @Eddysoulo haben einen Udemy Course erstellt, kostet zwar etwas aber die bieten alles was Anfänger brauchen.
Für Hilfe bin ich aber auch fast immer da (Link in der Signatur)

Edit: da war wieder Jemand schneller als ich

Rhazul · 1. Juli 2016, 18:07

Ätschibätsch ich war schneller

Belial · 1. Juli 2016, 18:13

Ja, hab mir auch schon gewünscht, dass ich dem Computer wie einem Menschen erklären könnte, welche Visionen mir vorschweben, um dann auf dem Bildschirm das Ergebnis präsentiert zu bekommen.

Aber so einfach wirds wohl noch lange nicht sein. Der Unterschied zwischen Gamemaker und zb. Visionaire oder RPGMaker ist ja, dass man mit Visionaire NUR Point and Click, mit RPGMaker NUR RPGs machen kann. Wogegen man mit dem Gamemaker theoretisch ALLES machen kann. Aber es wäre ja fast Wahnsinn, wenn der Gamemaker auch noch eine rpg engine, eine point and click engine, eine topdown shooter engine, eine strategiespiel engine, eine tetris engine, eine textadventure engine, eine sokoban engine, eine bejewel engine, eine jumpnrun engine und eine cookie clicker engine haben würde. Die alle eben doch nicht so recht nach dem eigenen Geschmack wären...
Ja, zu Beginn ist Gamemaker nicht einfach zu verstehen. Und ein komplett eigenes Spiel auf die Beine zu stellen ist lange harte Arbeit. Aber je mehr Erfahrung man sammelt, desto schneller, flexibler und intelligenter kann man mit Gamemaker Spiele basteln. Gewisse Elemente, von bestehenden Spielen, kann man in neuen Spielen auch wiederverwerten, ohne das Rad neu erfinden zu müssen. Kurzerhand, alles eine Frage der Einstellung und Ausdauer. :huh:

PS: Bei allem Lob für Gamemaker. Meiner Meinung nach gäbe es noch REICHLICH Luft nach oben, in Sachen Benutzerfreundlichkeit und Funktionsumfang.

Belial · 1. Juli 2016, 18:15

Rhazul schrieb:

Ätschibätsch ich war schneller

Ätschibätschibätsch! Ich war der Lahmste.

VoidByte · 1. Juli 2016, 18:26

@Rhazul
Danke für deine Antwort. Aber ich fürchte mein Beitrag ist falsch aufgenommen worden.
Ich spreche C#, Ruby und ActionScript 3 (und wenn man das dazurechnen möchte auch SQL, HTML und CSS).
Da bereitet mir GML keine schlaflosen Nächte. Es geht mir viel mehr darum, dass es notwendig ist, erstmal eine "Dialogengine" zu programmieren
um dann überhaupt einen Dialog schreiben zu können. Das sowas nicht Standartmäßig vorhanden ist und man nur noch sagen muss:
"start_dialog(mydialog1, player);". Ich mein es ist doch eine GAME engine oder?

Wenn ich all die ganzen Einzelteile die ein Spiel benötigt erstmal selbst schreiben muss.. wo hilft mir GMS dann noch? Wie ich schon sagte, dann kann ich auch mit
C anfangen Ogre zu coden. Das is praktisch auch nur ne Grafikengine ohne alles. Das einzige was ich bisher als "Hilfestellung" seitens GMS identifizieren konnte ist die
Code Completion im Code editor. Ansonsten muss ich ja wirklich noch ALLES selbst schreiben.
Mir scheint so als brächte man ein Framework für GMS, das einem die standartsachen die man sowieso IMMER braucht, schon mal bereitlegt.
Ich meine.. wieso z.B. ist keine Eingabesteuerung fest implementiert die Controller, Joysticks, Tastatur und Maus direkt out-of-the-box möglich macht?
Wenn einem die basics dann nicht gefallen, könnte man sie immer noch nach eigenen Wünschen umgestalten. Aber sie wären wenigstens schon da.
Ein Dialogeditor, weil Yoyo sich sicher denken kann das es spiele gibt, in denen gesprochen wird.
Einen Overlay / GUI editor, weil es nunmal meines wissens nach kein Spiel ohne gibt.
Einen Leveleditor der nicht erst zu jedem Object ein Sprite braucht sondern versteht das mache Sprites eben Objects sind und diese entsprechend behandelt. (Wenn ich in der CryEngine eine Mauer in den Raum setze, dann versteht die engine das es eine Mauer ist, auch ganz ohne das ich ihr das vorher mit 20 Skripten erklären muss.)

Kannst du dir eine Point-And-Click Adventure Engine vorstellen, bei der man erst die Mausteuerung und dann das movement dazu programmieren muss?
Oder eine Rollenspiel-Engine, bei der es keine Player Klasse gibt?
Mir erscheint es so, als sei GMS ein Editor ohne alles.

Übrigens, um das mal in Bilder zu fassen. Was diese Dialog-Geschichte angeht beziehe ich mich hier auf diese 2 Videos:
Video 1 = 4 Dateien und über 50 Zeilen code. Um eine graue Box auszugeben in der ein Einzeiler erscheint.
Video 2 = genau das selbe.. für ein Schild auf dem eine Sprechblase erscheint.
Und das sind Monologe. Ich will gar nicht ermessen wie viel Arbeit 50 Dialoge für 50 NPCs sein würden wenn ich das jedes mal für jeden char tippen müsste bevor ich überhaupt erst ANFANGEN kann, den eigentlich gesprochenen Text irgendwo einzugeben.

Es ist einfach, das ich nicht nachvollziehen kann, wieso soviel mehr-arbeit notwendig ist, für etwas grundlegend-selbstverständliches.
Ich habe vor eine Wirtschafts-Simulation mit Point-and-Klick Steuerung im 2D Profil (leicht Isometrischen) setting zu realisieren. Und momentan sehe ich mich noch in 2 Jahren Systeme am schreiben die irgendwann mal als Grundlage dienen werden, mit der eigentlichen Spielentwicklung zu beginnen.

@Husi012
Ja danke dir. Aber an Hilfestellungen und Tutorials herrscht wirklich kein Mangel. Ehr nach solchen die mir nicht zum hundertsten mal erklären wie ich einen Plattformer oder ein JRPG bastel. Ein "wie mache ich einen Diablo clon" oder "Maniac Mansion leicht gemacht" oder "Dein eigenes Papers Please!" Video-Tutorial, DAS wäre mal ne Hausnummer. Aber das hab ich in über 100 Youtube Videos nicht mal im geringsten Ansatz gefunden. Es ist immer nur "Wie kann ich einen Sprite erstellen", "wie mache ich ein Object daraus", "wie steuer ich das ganze durch den Room" etc.. Highlights sind dann noch State-Machines und sowas. Aber nichtmal bis zur GUI/Overlay oder AI Programmierung reichen die Videos auf YT. Sprich... AI die über "Bewege dich auf den Spieler zu" hinaus geht, versteht sich.

Was ja der Grund ist, wieso ich langsam denke das GMS auch nicht zu viel mehr wirklich geeignet ist, als eben diese Plattformer, Knobelspiele und vorallem JRPGs

Rotfuchs7 · 1. Juli 2016, 18:39

Auch wenn es so ist das GM:S keine fertigen engine dabei hat, finde ich den GM dennoch am übersichtlichsten und leicht zu verstehen.
Ich hatte immer meine Probleme mit den anderen engine. Die haben mich gleich so überfordert und ich bin nicht jemand der dieses Fachgebiet gelernt hat wie viele andere hier.

Dennoch habe ich immer großes Interesse dafür gehabt und durch den GM konnte ich eine gute Lernkurve erziehlen. Deswegen habe ich mich für den GM entschieden...auch wenn ich ihn immer noch nicht gekauft habe. xD

Genug von meiner Lebensgeschichte, sei mal ehrlich die mehrzahl der Spiele die mit einer engine zusammengeschustert wurden wirken meist echt billig und sind nur auf schnelles Geld aus.
Es fehlt das gewisse etwas bei sollchen spielen und das schlimmste, sie sehen alle gleich aus, verhalten sich auch gleich und übersättigen den Markt. Zudem hat man mit dem GM wirklich viel Freiraum.

Und wie meine Mama immer sagte: Selbst gemacht schmeckt immer noch am besten.

Husi012 · 1. Juli 2016, 18:41

Ich habe mir jetzt das Video nicht angeschaut, aber ich denke mal, dass sich dort der Text selber anpassen kann. Eine einfache graue Box mit einem Einzeiler würde gerade mal 4 einfache Code Zeilen Arbeit sein.
Für 50 NPCs brauchst du nur ein mal Arbeit leisten (wenn du es gut machst)

GameMaker bietet einfache Möglichkeiten Entfernungen zu messen, gute Kollisionserkennungen, Physik Engine, sehr leichte Multiplayer Engine.
Dazu dann noch einfache Bedienungen, das Sichtfeld an den Spieler anzuheften(2 Zeilen code), A* Pathfinding Engine vorhanden usw.
Und Vorallem: GameMaker ist seehr performant.

Rhazul · 1. Juli 2016, 18:50

Die stärke des GM liegt vorallem in seinen vielen vorgefertigten Funktionen sowohl auf Mathematischer/trigonomischer Seite(point_direction,point_distance etc) als auch Grafisch. Ich denke dich stört es das gerade die Dialoge nicht dabei sind , da dein Spiel ja darauf basiert. Aber wenn man es so betrachtet, wenn es eine Hauptfunktionalität sein soll, sollte es dann nicht auch perfekt maßgeschneidert sein? So ein Dialogfenster kann man fast komplett im Draw Event schreiben, ich denke du wirst noch nicht auf 50 zeilen kommen.

Eingabesteuerung: Was ist konkret das Problem? Unter den Events findest du sowohl Maus, als auch Tastatureingabe. Ein Gamepad oder virtual keys einzubnauen lässt sich mit 10 - 20 Zeilen realisieren, funktionen zum Auslesen der Achsen etc sind vorhanden.

Was soll ein GUI Editor deiner Meinung nach tun? Die Grafiken musst du nunmal selbst erstellen, Die Positionierung der Elemente kann dir auch kein Computer abnehmen, das tut man eben durch code. Die meißten Elemente lassen sich durch einen einzigen Befehl darstellen. Unter Draw gibt es ein Extra GUI Layer, dieser wird automatisch oben auf die Scene aufgetragen.

Es gibt auf YT sehr wohl Forschrittliche Tutorials, diese sind aber meist auf Englischer Sprache vorzufinden.
Und wenn du nun schon reichlich Programmiererfahrung gesammelt hast, dann bräuchtest du eigentlich auch keine Tutorials zu spezifischen Sachen. Das Handbuch kann schon echt Helfen, wenn man was zu pathfinding nicht versteht oder sich der Funktionen uinsicher ist kann man da alles nachlesen.

VoidByte · 1. Juli 2016, 19:13

Na natürlich sind die auf Englisch ;D
Aber leider habe ich noch keins gefunden das über die Dinge hinausgeht die ich im letzten Post beschrieb. Oh doch! Eins hat eine WebAPI angesprochen, das war in der Tat äußerst hilfreich.. aber sonst fiele mir keins ein.

Und ja, es mangelt an allem. Pathfinding mit den "Pathes" zu verknüpfen z.B. Isometrische sicht so hinbekommen das ich trotz

GML-Quellcode

depth = -y;

nicht in die mauer laufe sondern dagegen, jedoch von der anderen Seite hinter besagter Mauer stehe.
Wozu Makros da sind, für welche sorte "extensions" der gleichnamige Ordner gut ist, wie man Timelines erstellt und mit ihnen Arbeitet,
Ach.. ich kann das gar nicht alles aufzählen. Es gibt tausende Dinge an denen es scheitert. Und da es keine Tutorials zu diesen Speziellen Themen gibt,
steh ich dann da, mit der Referenz auf dem Bildschirm und einem riesigen Fragezeichen über dem Kopf. Und für all diese kleinen Fragen müsste ich hier einen extra
Thread erstellen um dann vermutlich fest zu stellen, das mir "Timelines" garnicht helfen bei meiner Idee.

@Steuerung:
Ich hab meine Steuerung, das ist nicht das Problem. Die Frage ist ehr, wieso ich die erst selbst programmieren musste. Was Point-and-Click angeht, da hab ich nichtmal
den hauch einer Ahnung wie ich das Thema überhaupt angehen soll. Ich hab zwar schon die X.Y Koordinaten in einem Array abgelegt. Aber da wenn ich x und y des spielers dann auf sie zubewegen will, läuft er halt gegen das nächst beste Hindernis und das noch nichtmal mit Animation. Ergo muss ich GMS dann auch noch sagen, das sowas selbstverständliches wie eine Laufanimation nicht nur bei Keyboard/Gamepad Steuerung abgespielt werden soll, sondern auch wenn der Charakter sich ohne tastendruck bewegt.. alleine raus zu finden wie das jetzt wieder funktioniert wäre schon wieder ein laaaanger Forenthread, da ja Skripte generell in kleinen fächern irgendwo im System abgelegt werden und nicht einfach ein großes Skript im Hintergrund läuft, wird das eine langer Weg. Tatsächlich steh ich noch an dem punkt, an dem ich rausbekommen will, wieso mein Charakter sich dauernd nach links dreht, statt auf dem Index Frame 0 stehen zu bleiben, dessen letzte Richtung er abspielte.
Soooo viele Fragen.. und zugrunde liegt nur eine Skript-Referenz und ein Forum das ich nicht überstrapazieren will.

Rhazul · 1. Juli 2016, 19:47

Das was du dir da herbeiwünschst ist ein Baukasten und keine IDE. Und da passiert nunmal nur das was man konkret befehlt. Ich könnte ja auch ein Objekt haben, verschiebe es, will aber in dem Moment garnicht seine Animation abspielen. Jedes Objekt hat von Haus aus ca 20 Grundvariablen wie speed, hspeed, vspeed, image_index,sprite_index, image_angle, image_speed etc. Diese kann man verwenden, muss man aber nicht. Das Ganze ist halt ziemlich abstrakt, ein Objekt was ich erstelle muss kein wirkliches physiches Objekt in der Spielewelt sein, es kann auch ein Controllerobjekt ein. Es gibt 1000 verschiedene Herangehensweisen, ich kann sagen move_towards_point, das benutzt dann en Objektinternen Speed und direction, dann könnte man noch die avoid funktion benutzen und schon geht dein männlein zur besagten position. Dann muss man ihm halt auch sagen das speed = 0 am ziel gesetzt werden soll. Wenn diese vorgegebenen Sachen nicht reichen muss man halt selbst ran, das Objekt kann auch durch direktes verändern der koordinaten bewegt werden. Dabei muss man sich bewusst machen, das das Objekt nicht wirklich DA (x/y) ist, sondern es ist im Speicher, hat variable x und variable y und standardmäßig wird dann halt auf dem Canvas an x/y da sprite gemalt. Das kann man aber auch komplett selber übernehmen, sogar an einer ganz anderen Position malen und die eigentlichen x/y positionen ignorieren. Was ich damit sagen will ist, das man in den Dingen nichts sehen darf was es nicht ist. Es ist eine IDE mit Programmiersprache so wie Eclipse mit Java oder C/#/++ IDEs, aber ,mit meiner Meinung nach Programmierfreundlicherem Syntax. Diese Vorgefertigten Sachen, welche Anfänger etwas auffangen sollen haben meiner Meinung nach den Effekt, dass man sich in nicht dargewesener Sicherheit verirrt.

& Damit dir deine Probleme vielleicht etwas einfacher vorkommen hier mal ein paar Ausschnitte mit was man sich in wirklich komplexen Problemen rumschlägt. Auszüge aus meiner WWYD Engine ( das ist ungefähr das was du dir unter deinem Framework verstehst, nur das ich da seit über 2 Jahren immer mal wieder Funktionalität erweitere. Sowas gibt es einfach nicht weil es unbezahlbar ist , quasi wie ein fast fertiges Spiel was einem geschenkt würde, und immer recht spezifisch. Der Vorteil ist das ich aber sehr viel in andere Projekte übernehmen kann).

Spoiler anzeigen

GML-Quellcode

///motion(right, up, left, forcedhsp, forcedvsp, force)
// CONTROLS //
//CONSOLE START//////////////////////////////////////////////////////////////////
if (!global.show_console) {
//RIGHT//
if(argument0-argument2==1) {
spr_dir = 1;
hsp = min( max_spd,hsp + acc_spd)*gunSpeedHandicap;
hunger_current -= 0.0005;
}
//LEFT//
if(argument2-argument0==1) {
spr_dir = -1;
hsp = max(-max_spd,hsp - acc_spd)*gunSpeedHandicap;
hunger_current -= 0.0005;
}
//JUMPING//
if(argument1==1) {
if(free==0 && hold==0) {
vsp = floor(jmp_spd-sign(jmp_spd)*abs(jmp_spd/3.5));
jump = 1;
}
if(free==1 && hold==1 && (vsp <= 0)) {
vsp -= grv_spd/2;
hunger_current -= 0.001;
}
hold = 1;
}else{
hold = 0;
}
}
//CONSOLE END/////////////////////////////////////////////////////////////////////
// FORCED MOTION
//////////////////
if(argument5==1) {
repeat(ceil(abs(argument3))) {
if(place_meeting(x+lengthdir_x(1,grv_dir+(sign(argument3)*90)),y+lengthdir_y(1,grv_dir+(sign(argument3)*90)),par_solid)==0) {
x+= lengthdir_x(1,grv_dir+(sign(argument3)*90));
y+= lengthdir_y(1,grv_dir+(sign(argument3)*90));
} else break;
}
repeat(ceil(abs(argument4))) {
if(place_meeting(x+lengthdir_x(1,grv_dir-90+(sign(argument4)*90)),y+lengthdir_y(1,grv_dir-90+(sign(argument4)*90)),par_solid)==0) {
x+= lengthdir_x(1,grv_dir-90+(sign(argument4)*90));
y+= lengthdir_y(1,grv_dir-90+(sign(argument4)*90));
} else break;
}
exit;
}
// HORIZONTAL MOVEMENT
////////////////////////
repeat(round(abs(hsp))) {
var blk, mov;
blk = place_meeting(x+lengthdir_x(1,grv_dir+(sign(hsp)*90)),y+lengthdir_y(1,grv_dir+(sign(hsp)*90)),par_solid);
mov = 0;
if(blk==1) {
for(a=1;a<=max_slp;a+=1) {
if(place_meeting(x+lengthdir_x(1,grv_dir+(sign(hsp)*90))-lengthdir_x(a,grv_dir),y+lengthdir_y(1,grv_dir+(sign(hsp)*90))-lengthdir_y(a,grv_dir),par_solid)==0) {
x += lengthdir_x(1,grv_dir+(sign(hsp)*90))-lengthdir_x(a,grv_dir);
y += lengthdir_y(1,grv_dir+(sign(hsp)*90))-lengthdir_y(a,grv_dir);
mov = 1;
break;
}
}
if(mov==0) {
if (abs(hsp) > global.minShakeSpeed/2) {
scr_shake_view(clamp(hsp*.35,-15,15));
}
hsp = 0;
break;
}
} else {
for(a=1;a<=max_slp && free==0;a+=1) {
lis = instance_place_list(x+lengthdir_x(1,grv_dir+(sign(hsp)*90))-lengthdir_x(a-1,grv_dir),y+lengthdir_y(1,grv_dir+(sign(hsp)*90))-lengthdir_y(a-1,grv_dir),par_jumpthrough);
if(lis!=noone) {
for(b=0;b<ds_list_size(lis);b+=1) {
jt = ds_list_find_value(lis,b);
if(place_meeting(x+lengthdir_x(1,grv_dir+(sign(hsp)*90))-lengthdir_x(a,grv_dir),y+lengthdir_y(1,grv_dir+(sign(hsp)*90))-lengthdir_y(a,grv_dir),jt)==0) {
x += lengthdir_x(1,grv_dir+(sign(hsp)*90))-lengthdir_x(a,grv_dir);
y += lengthdir_y(1,grv_dir+(sign(hsp)*90))-lengthdir_y(a,grv_dir);
mov = 1;
break;
}
}
if(mov==1){ds_list_destroy(lis);break;}
ds_list_destroy(lis);
}
}
if(mov==0) {
for(a=max_slp;a>=1;a-=1) {
if(place_meeting(x+lengthdir_x(1,grv_dir+(sign(hsp)*90))+lengthdir_x(a,grv_dir),y+lengthdir_y(1,grv_dir+(sign(hsp)*90))+lengthdir_y(a,grv_dir),par_solid)==0 && (place_meeting(x+lengthdir_x(1,grv_dir+(sign(hsp)*90))+lengthdir_x(a,grv_dir),y+lengthdir_y(1,grv_dir+(sign(hsp)*90))+lengthdir_y(a,grv_dir),par_jumpthrough)==0 && sign(vsp)>-1)) {
if(place_meeting(x+lengthdir_x(1,grv_dir+(sign(hsp)*90))+lengthdir_x(a+1,grv_dir),y+lengthdir_y(1,grv_dir+(sign(hsp)*90))+lengthdir_y(a+1,grv_dir),par_solid)==1 || place_meeting(x+lengthdir_x(1,grv_dir+(sign(hsp)*90))+lengthdir_x(a+1,grv_dir),y+lengthdir_y(1,grv_dir+(sign(hsp)*90))+lengthdir_y(a+1,grv_dir),par_jumpthrough)==1) {
x += lengthdir_x(1,grv_dir+(sign(hsp)*90))+lengthdir_x(a,grv_dir);
y += lengthdir_y(1,grv_dir+(sign(hsp)*90))+lengthdir_y(a,grv_dir);
mov = 1;
break;
}
}
}
}
if(mov==0) {
x+= lengthdir_x(1,grv_dir+(sign(hsp)*90));
y+= lengthdir_y(1,grv_dir+(sign(hsp)*90));
}
}
}
// VERTICAL MOVEMENT
//////////////////////
var stop;
stop = 0;
repeat(round(abs(vsp))) {
if(place_meeting(x+lengthdir_x(1,grv_dir-90+(sign(vsp)*90)),y+lengthdir_y(1,grv_dir-90+(sign(vsp)*90)),par_solid)==1) {
//Falldamage
calculate_falldamage();
if (abs(vsp) > global.minShakeSpeed) {
scr_shake_view(clamp(vsp*.25,-15,15));
}
vsp = 0;
landed = 1;
break;
}
/*
if(place_meeting(x+lengthdir_x(1,grv_dir-90+(sign(vsp)*90)),y+lengthdir_y(1,grv_dir-90+(sign(vsp)*90)),par_jumpthrough)==1) {
}
*/
var jt, lis;
lis = instance_place_list(x+lengthdir_x(1,grv_dir),y+lengthdir_y(1,grv_dir),par_jumpthrough);
if(lis!=noone) {
for(a=0;a<ds_list_size(lis) && sign(vsp)==1;a+=1) {
jt = ds_list_find_value(lis,a);
if(place_meeting(x,y,jt)==0) {
//Falldamage
calculate_falldamage();
if (abs(vsp) > global.minShakeSpeed) {
scr_shake_view(clamp(vsp*.25,-15,15));
}
vsp = 0;
landed = 1;
break;
}
}
ds_list_destroy(lis);
}
if(vsp==0)break;
x+= lengthdir_x(1,grv_dir-90+(sign(vsp)*90));
y+= lengthdir_y(1,grv_dir-90+(sign(vsp)*90));
}
free = 1;
if(place_meeting(x+lengthdir_x(1,grv_dir),y+lengthdir_y(1,grv_dir),par_solid)==1) {
free = 0;
}
var jt, lis;
lis = instance_place_list(x+lengthdir_x(1,grv_dir),y+lengthdir_y(1,grv_dir),par_jumpthrough);
if(lis!=noone) {
for(a=0;a<ds_list_size(lis);a+=1) {
jt = ds_list_find_value(lis,a);
if(sign(vsp)>-1 && place_meeting(x,y,jt)==0){free=0;break;}
}
ds_list_destroy(lis);
}
// GRAVITY & FRICTION
///////////////////////
if(argument5==0) {
if(free==1) {
vsp+=grv_spd;
if(argument0-argument2==0){hsp=max(0,abs(hsp)-air_frc)*sign(hsp);}
} else {
jump = 0;
if(argument0-argument2==0){hsp=max(0,abs(hsp)-gnd_frc)*sign(hsp);}
}
}

Alles anzeigen

Oder Hier mal Inverse Kinematik für Armbewegungen

Spoiler anzeigen

GML-Quellcode

///player_draw_right()
texture_set_interpolation(false); // disable linear interpolation
pck_visuals = "";
var bicep_length,forearm_length,arm_dist,clampDist,phi,theta,omega,bicep_x,bicep_y,forearm_x,forearm_y,forearm_angle;
var drawScale = .5; // used to bring artwork back to 100% scale
var bobbing = 0;
var weaponOffset_x = global.weaponOffset_x;
var weaponOffset_y = global.weaponOffset_y;
if (armed) {
var armAngOffset =-global.armAngOffset; // front arm rotation offset
var armRad = global.armRad; // radius, determines hand position
var armDistOffset = global.armDistOffset; // distance from back hand to front hand towards aim direction
var armRotClamp = global.armRotClamp; // permitted arm rotation
var torsoSprite = spr_plr_torso_right;
var headSprite = spr_plr_head_right;
var weaponSprite = global.weaponSprite;
var bicepSprite = spr_plr_bicep;
var forearmSprite = spr_plr_forearm;
sprite_set_offset(weaponSprite,weaponOffset_x,weaponOffset_y); // set the weapons offset
if (muzzleIndex > 2 + muzzleDelay) { //recoil
bobbing = -1;
}
var torsoOffset_x = sprite_get_xoffset(torsoSprite)*drawScale; // torso xoffset
var torsoOffset_y = sprite_get_yoffset(torsoSprite)*drawScale; // torso yoffset
var armF_x = x - torsoOffset_x + 8; // front arm shoulder joint xpos
var armF_y = yDrawPos - torsoOffset_y + 14; // front arm shoulder joint ypos
var armB_x = x - torsoOffset_x + 16; // back arm shoulder joint xpos
var armB_y = yDrawPos - torsoOffset_y + 14; // back arm shoulder joint ypos
aimDir = scr_clamp_direction(aimDir,0,armRotClamp); // clamp direction
handF_x = armF_x + lengthdir_x(armRad + bobbing,aimDir + armAngOffset); // front arm hand xpos
handF_y = armF_y + lengthdir_y(armRad + bobbing,aimDir + armAngOffset); // front arm hand ypos
var handDirB = aimDir//point_direction(handF_x,handF_y,mouse_x,mouse_y); // direction from front to back hand
handDirB = scr_clamp_direction(handDirB,0,armRotClamp); // clamp direction
var handB_x = handF_x + lengthdir_x(armDistOffset,handDirB); // back arm hand xpos
var handB_y = handF_y + lengthdir_y(armDistOffset,handDirB); // back arm hand ypos
}else{
var armAngOffset = 0; // front arm rotation offset
var armRad = 15; // radius, determines hand position
var armDistOffset = 0; // distance from back hand to front hand towards aim direction
var armRotClamp = 120; // permitted arm rotation
var torsoSprite = spr_plr_torso_right;
var headSprite = spr_plr_head_right;
var weaponSprite = msk_none;
var bicepSprite = spr_plr_bicep;
var forearmSprite = spr_plr_forearm;
var torsoOffset_x = sprite_get_xoffset(torsoSprite)*drawScale; // torso xoffset
var torsoOffset_y = sprite_get_yoffset(torsoSprite)*drawScale; // torso yoffset
var armF_x = x - torsoOffset_x + 8; // front arm shoulder joint xpos
var armF_y = yDrawPos - torsoOffset_y + 14; // front arm shoulder joint ypos
var armB_x = x - torsoOffset_x + 16; // back arm shoulder joint xpos
var armB_y = yDrawPos - torsoOffset_y + 14; // back arm shoulder joint ypos
aimDir = scr_clamp_direction(aimDir,0,armRotClamp); // clamp direction
var m1 = 0;
if (image_index < image_number/2) {
m1 = -(image_index*1.5);
}else{
m1 = (image_index - image_number/2)*1.5;
}
var m2 = 0;
if (image_index < image_number/2) {
m2 = (image_index - image_number/2)*1.5;
}else{
m2 = -(image_index*1.5);
}
handF_x = armF_x + lengthdir_x(armRad,280 +m1)+-2; // front arm hand xpos
handF_y = armF_y + lengthdir_y(armRad,280 +m1)+1; // front arm hand ypos
var handB_x = armB_x + lengthdir_x(armRad,280 +m2)-1; //+ lengthdir_x(8,aimDir + armAngOffset); // back arm hand xpos
var handB_y = armB_y + lengthdir_y(armRad,280 +m2); //+ lengthdir_y(8,aimDir + armAngOffset); // back arm hand ypos
}
//BACK ARM//
bicep_length = (sprite_get_width(bicepSprite) - sprite_get_height(bicepSprite))*drawScale; // length of bicep element
forearm_length = (sprite_get_width(forearmSprite) - sprite_get_height(forearmSprite))*drawScale; // length of forearm element
arm_dist = point_distance(armB_x, armB_y, handB_x, handB_y); // distance from shoulder to hand
clampDist = clamp((sqr(arm_dist)-sqr(bicep_length)-sqr(forearm_length))/(-2*bicep_length*forearm_length),-1,1);
phi = arccos(clampDist); // phi
theta = pi - phi; // theta
omega = arcsin(forearm_length*sin(phi) / arm_dist); // omega
bicep_x = armB_x; // bicep xpos
bicep_y = armB_y; // bicep ypos
bicep_angle = point_direction(armB_x, armB_y, handB_x, handB_y) - radtodeg(omega); // bicep angle
forearm_x = armB_x + lengthdir_x(bicep_length, bicep_angle); // forearm xpos
forearm_y = armB_y + lengthdir_y(bicep_length, bicep_angle); // forearm ypos
forearm_angle = bicep_angle + radtodeg(theta); // forearm angle
draw_sprite_ext(forearmSprite,0,forearm_x,forearm_y,drawScale,drawScale,forearm_angle,image_blend,image_alpha); // draw front arm forearm element
draw_sprite_ext(bicepSprite,body_index,bicep_x,bicep_y,drawScale,drawScale,bicep_angle,image_blend,image_alpha); // draw front arm bicep element
/*
pck_visuals = "" + string(forearm_x) + "#" + string(forearm_y) + "#" + string(forearm_angle) + "#" + string(bicep_x) + "#"
+ string(bicep_y) + "#" + string(bicep_angle);
*/
//--------//
//FRONT ARM//
bicep_length = (sprite_get_width(bicepSprite) - sprite_get_height(bicepSprite))*drawScale; // length of bicep element
forearm_length = (sprite_get_width(forearmSprite) - sprite_get_height(forearmSprite))*drawScale; // length of forearm element
arm_dist = point_distance(armF_x, armF_y, handF_x, handF_y); // distance from shoulder to hand
clampDist = clamp((sqr(arm_dist)-sqr(bicep_length)-sqr(forearm_length))/(-2*bicep_length*forearm_length),-1,1);
phi = arccos(clampDist); // phi
theta = pi - phi; // theta
omega = arcsin(forearm_length*sin(phi) / arm_dist); // omega
bicep_x = armF_x; // bicep xpos
bicep_y = armF_y; // bicep ypos
bicep_angle = point_direction(armF_x, armF_y, handF_x, handF_y) - radtodeg(omega); // bicep angle
forearm_x = armF_x + lengthdir_x(bicep_length, bicep_angle); // forearm xpos
forearm_y = armF_y + lengthdir_y(bicep_length, bicep_angle); // forearm ypos
forearm_angle = bicep_angle + radtodeg(theta); // forearm angle
var drawScale = .5;
//---------//
draw_sprite_ext(sprite_index,image_index,x,y,drawScale,drawScale,0,feet_colour,image_alpha); // draw feet
draw_sprite_ext(torsoSprite,body_index,x,yDrawPos,drawScale,drawScale,0,image_blend,image_alpha); // draw torso
draw_sprite_ext(headSprite,head_index,x,yDrawPos,drawScale,drawScale,0,image_blend,image_alpha); // draw head
if (armed) {
draw_sprite_ext(weaponSprite,-bobbing,handF_x,handF_y,drawScale,drawScale,aimDir,c_white,1); // draw weapon
}
draw_sprite_ext(forearmSprite,0,forearm_x,forearm_y,drawScale,drawScale,forearm_angle,image_blend,image_alpha); // draw front arm forearm element
draw_sprite_ext(bicepSprite,body_index,bicep_x,bicep_y,drawScale,drawScale,bicep_angle,image_blend,image_alpha); // draw front arm bicep element
/*
pck_visuals += "#" + string(forearm_x) + "#" + string(forearm_y) + "#" + string(forearm_angle) + "#"
+ string(bicep_x) + "#" + string(bicep_y) + "#" + string(bicep_angle) + "#" + string(bobbing) + "#"
+ string(weaponOffset_x) + "#" + string(weaponOffset_y) + "#" + string(xDrawPos) + "#" + string(yDrawPos);
*/

Alles anzeigen

Rotfuchs7 · 1. Juli 2016, 19:58

Und es gibt eine Suchfunktion in diesem Forum.

Ganz oben rechts da steht "Aktuelles Forum durchsuchen" es funktioniert fast wie Google, es sucht die Wörter raus die du dort oben eingegeben hast.
Es wurden schon sehr viele dinge hier besprochen, wahrscheinlich auch deine Problematiken und wenn du dennoch nicht weiter kommst, weil es an einer Textbox scheitert oder an der Steuerung, wird dir die Community auf jedenfall helfen wenn nicht sogar Code Beispiele geben.
Dies ist ein Forum, dass heißt hier kannst du Fragen stellen, um hilfe bitten und Erfahrungen austauschen.

Versuch es mal. Zudem gibt es noch eine Einsteigerrefferenz die dir viele dinge als GM:S Anfänger noch genauer erklärt.

Aufs falsche Pferd gesetzt?

Aufs falsche Pferd gesetzt?

GML-Quellcode

Rhazul schrieb:

GML-Quellcode

GML-Quellcode

GML-Quellcode

Tags

Ähnliche Themen