Ergebnis 1 bis 15 von 15

Thema: Flexibles "skill pointer" System ... oder so?!

  1. #1

    Flexibles "skill pointer" System ... oder so?!

    Hallo,

    ich plane gerade, ein paar neue Skills (für die die das Spiel kennen "Mods") in mein KS zu integrieren und merke, dass mein gegenwärtiges System reichlich unflexibel ist.

    Ich schildere kurz, wie das ganze gegenwärtig funktioniert. Der Auswahlbildschirm sieht so aus:


    Die Positionen der einzelnen Skills sind fest. Sieht man auch daran, dass es ne Lücke gibt. Das hat auch den Sinn, dass die Skills eigentlich immer die gleiche Zahl zugewiesen haben sollten, damit man das auch im Gehirn zusammen bringt und den gewünschten Skill möglichst schnell anwählen kann.
    Drücke ich also eine der Zahlen, wird der Skill (/Mod) ausgewählt und die Variable "Aktiv Mod Chara X" wird gleich eben diese Zahl gesetzt. Für die Auswirkungen in anderen Common Events wird dann wieder abgefragt ob die Variable den Wert hat. Wenn ja, wird quasi der wie auch immer geartete Skill-Effekt aktiviert.

    Problem:

    Wenn man sich das so durchdenkt, kommt man wohl schnell drauf, welche Probleme es beim einfügen eines neuen Skills geben könnte. Angenommen ich würde an erster Stelle eine Mod einfügen, also zwischen 1 und 2 (wäre dann die neue 2):
    1. Ich muss das ganze grafisch anpassen. Das wäre wohl das kleinere Problem.

    2. Jede Mod die noch darunter kommt, würde eine neue Zahl bekommen.
    Hier habe ich so wie ich das sehe 2 Möglichkeiten: Die chaotische oder die ordentliche Tour.

    Die chaotische Tour würde bedeuten: Ich schiebe das ganze optisch nach unten und jede Mod bekommt eine neue Zahl. Wählt man diese Zahl dann jedoch an, um die Mod auszurüsten, wird die Variable "Aktiv Mod Chara X" gleich der alten Zahl gesetzt, die für die Mod stand. Anzeigezahl und tatsächliche Zahl unterscheiden sich dann also. Damit ist es nicht so viel Arbeit, kann aber evtl zu Verwirrung führen. Aber ehrlich gesagt, sehe ich grad nur das als Option.

    Die ordentliche Tour würde bedeuten: Ich passe alles an. Also überall wo "Aktiv Mod Chara X" abgefragt wird, muss ich die Werte anpassen. Das ist nicht nur ein Haufen Arbeit, sondern auch verdammt fehleranfällig. Das hab ich ein Mal gemacht und werd in Zukunft die Finger von lassen.


    Ja, was will ich jetzt von euch?

    Wie immer, wenn ich sowas frage, gehe ich davon aus, dass hier viele schlaue Köpfe anwesend sind und auch solche, die ein bisschen mehr Erfahrung mit "richtigem" Programmieren haben. Deshalb wäre es nicht das erste Mal, dass jemand von außen drauf schaut und spontan noch eine bessere Lösung sieht, als die die ich jetzt erwäge. Darüber würde ich mich sehr freuen.

  2. #2
    Du nutzt den 2k/3, richtig? Wie wäre es denn, wenn du es "intern" über Skills regelst - sprich, du erstellst pro Mod einen Skill und fragst dann einfach ab, ob der Skill von jemandem erlernt wurde? Das kannst du gut mit Pointern durchiterieren und kannst in der Maker-Database ein paar Lücken lassen, falls du noch was hinzufügst.

    In dem Menü kannst du das dann ja dann mehr oder weniger dynamisch machen, dass sich die Reihenfolge an der in der Database orientiert - dann kannst du dort hin- und herschieben, wie du lustig bist und das Script schaut dann, in welcher Reihenfolge der Spaß eingetragen ist.

  3. #3
    Hey,
    danke erstmal, dass du dich damit beschäftigt hast. ^^
    Es fällt mir gerade nur etwas schwer, deinen Vorschlag gedanklich auf mein System zu übertragen bzw überhaupt zu verstehen. Vielleicht mangelt es auch an Informationen deinerseits. Ich kann mich noch nicht so recht in den Vorteil des internen Skill Systems hineindenken.
    Ich versuche mal, dass wir uns irgendwie verständigen können:

    Du meinst, ich soll Forks einbauen "if actor learned skill ???", richtig? Diese sollen dann für die Darstellung bei der Auswahl oder beim Anwenden der Effekte der Mods zum Einsatz kommen?

    Noch ein paar Infos:
    Falls du meinst, ich kann die Auswirkungen, welche Mod ausgerüstet ist, damit abfragen, ist das wohl ein Missverständnis. Dafür wird ja eine Variable abgefragt. Das heißt hier erschließt sich mir nicht, wozu die Skills gut wären. Es sei denn, ich würde die jeweils ausgerüstete Mod dem Charakter lernen und alle anderen wieder verlernen, so würde es wohl irgendwie Sinn machen, aber das geht mit der Variable leichter. ^^

    Andere Sache, die bei deinem Vorschlag u.U. Probleme machen könnte: Das lernen einer Mod wird ebenfalls per Variable gesteuert. Wenn also eine Mod erlernt wird, wird zB die Variable 1 gesetzt (außer bei denen, die man schon von Beginn an hat). Die Effekte sind allerdings steigerbar, das heißt, man kann die Mods erweitern und der Einfachheit halber wird dann die Variable gesteigert, sie kann also verschiedene Stati haben. Das erscheint mir problematisch, weil das bei einem Skill nicht geht und ich ja nur abfragen kann, ob er gelernt wurde oder nicht.

    Ich hoffe, das hilft ein bisschen uns zu verständigen. ^^

  4. #4
    Mh, ja, die Upgrade-Sache zerschießt da meine Idee etwas. Dein Problem ist ja, wenn ich das richtig verstehe, dass du hinterher Sachen hinzufügen möchtest, und das aber 1) in der Variablenliste irgendwie halbwegs geordnet haben möchtest und 2) dass die Ordnung im GUI auch noch klappen soll?

    Das erstere ist ja ein sehr spezifisches Maker-Problem und da hilft fürchte ich auch nur entweder große Lücken lassen bzw gut vorher Planen - wobei, sagen wir, 100 Variablen nur für Mods reservieren ja jetzt kein Thema sein sollte. Zu zwei: Wie wäre es, wenn du zwei Ziffern der Variable fürs Sortieren nimmst? Das ist etwas hakelig (und, again, sehr Maker-spezifisch...), aber so könnte es u.U. gehen?

    Sagen wir Variable 0001 ist für Mod1 da und sieht bei maximal 4 möglichen Charakteren wie folgt aus: 11301. Die hintersten vier Stellen geben dabei an, welcher Char welches Upgrade hat (bzw ob er/sie den Skill kann) - Char 1 hat den Skill auf 1, Char 2 auf 3, Char 3 kann ihn gar nicht, Char 4 hat ihn auch auf 1. Die Ziffern davor geben an, an welcher Stelle der Liste der Mod steht (hier also an erster Stelle). Jetzt fügst du später in Variable 0023 aber einen Mod ein, der stattdessen ganz oben sein soll - das geht nun ganz einfach, indem du die Variable mit 1 anfängst (bspw. 10000, wenn keiner den Mod bisher kann) und die Variable für Mod1 dann einfach auf 21301 änderst (das könnte man ja zentral in nem CE verwalten und müsste nur einmal gemacht werden, wenn du feste Listenplätze willst). Auslesen kannst du den Spaß dann mittels Modulo.
    Ob das geht hängt aber dann sehr davon ab, wie viele Chars du hast. Wenn du in der Variable nur unterbringen willst, welchen Listenplatz der Mod hat (1 bis 99) sowie ob ein Char den Skill kann bzw. wie gut (0 für "nein" und dann 1-9 (theoretisch)) würdest du da 6 Charaktere unterbringen können (da der Maker bis zu 8 Ziffern unterbringen kann).

    Wenn der Platz nicht reicht kannst du auch mit Pointern arbeiten, sprich, Ziffer 1+2 geben den Listenplatz an, die 4 danach die ID der Variable, wo dann alles weitere gespeichert ist. Wenn du die von der Reihenfolge dann immer gleich aufbaust, kannst du da dann bequem mit +1 durch-iterieren, bspw. wenn Variable 0001 "Mod1_Char1" für Char 1 da ist, 0002 für "Mod1_Char2", usw. Wichtig ist da dann einfach, dass du immer den selben Aufbau im Variableneditor verwendest.

    Du brauchst ja im Prinzip einfach nur eine Möglichkeit, beim hinzufügen neuer Skills die Reihenfolge der Mods noch im Nachhinein zu verändern, sprich, du musst das irgendwie dynamisch festlegen und dann auch dynamisch abfragen. Das geht aber nur, wenn du die Reihenfolge wiederum in irgendeiner Variable festlegst und dann vor der Anzeige im Menü einmal anhand dieses Wertes durchsortierst.

    ...wenn es das auch nicht ist fehlen mir entweder Infos, oder ich verstehe das Problem doch noch nicht so ganz.

  5. #5
    Danke für die Überlegungen. Ich glaube, du liegst immer noch ein wenig neben dem, worum es mir geht. Aber immerhin haben deine Überlegungen meine eigenen angestoßen und ich glaube, es reift gerade etwas. xD

    Zitat Zitat
    1) in der Variablenliste irgendwie halbwegs geordnet haben möchtest
    Das ist nicht mein Anliegen. Da geht es so oder so kreuz und quer zu. ^^

    Was du bei deinen anderen Überlegungen wohl nicht bedacht hast, ist dass die Mods völlig charakterspezifisch sind. Das heißt, jeder Charakter hat eigene. Ich bin aber noch nicht sicher, ob das dafür wichtig wäre, was du beschreibst.

    Ich glaube jedenfalls, mein Gehirn hat grad ne Lösung gefunden. Ich melde mich nochmal mit meiner Lösung oder evtl weiteren Problemen. ^^

  6. #6
    Okay, ich glaube, ich brauche doch nochmal Hilfe. Das Problem ist, dass ich immer nur in der Lage bin solche Skripte ganz rudimentär oder abstrakt im Kopf zu durchdenken. Beim Aufbau brauche ich dann eine Menge Trial and Error, um langsam zu dem zu kommen, was abstrakt in meinem Kopf ganz gut funktioniert hat.

    Ich versuche mal zu erklären, worin meine Lösung jetzt besteht.
    Nochmal kurz zusammengefasst: Jeder Charakter kann bis zu 9 dieser Mods von jeweils 3 Mod-Typen erlernen (also insgesamt bis zu 27).


    Man kann im Kampf mit den Pfeiltasten zwischen Typen hin und her schalten. Mit den Zahlen wählt man die Mods aus.
    Mein Wunsch war es jetzt, das System möglichst so flexibel zu halten, dass ich jeder Zeit die Reihenfolge der Mods verändern oder auch neue Mods einschieben kann.

    So sieht ein Code-Block zur Anzeige einer Mod aus:


    Die Ganze Anzeige funktioniert also auch über Pointer, wie man sieht. Auch die Picture ID hab ich grad auf Variable umgestellt (echt coole Erweiterung mit dem letzten Update). So nimmt die Mod also grafisch automatisch ihren Platz ein, je nachdem wo man sie im Code platziert.
    Entscheidend ist nun die markierte Variable. Diese ist platzspezifisch. Sie ist das einzige, was man ändern muss, will man die Position verändern. Denn der Wert der Variable entspricht einer zugeordneten Mod.
    Jetzt hab ich die Werte natürlich erstmal hintereinander weg zugeordnet. Variable Mod 2 = 2, das entspricht der Mod "Fernwirkung", wie man sieht. Variable Mod 3 = 3, das entspricht der Mod "MP Saugen".
    Würde ich die beiden allerdings vertauschen, müsste ich Variable Mod 2 = 3 und Variable Mod 3 = 2 setzen.

    Jetzt zum Problem:
    Durch diese Variable kann also herausgefunden werden, an welcher Position sich welche Mod befindet.
    Der nächste Schritt ist das Drücken einer Zahlentaste, was diese Fork öffnet:


    ... und man sieht, sie ist leer. Was ich gerade nicht hinbekomme ist, aus den gegebenen Informationen für 3 Charaktere und jeweils 3 Modtypen in einem übersichtlichen Skript, die Mods auszurüsten. Das heißt, die Variable "Charakter X Mod Typ 1" gleich den richtigen Wert zu setzen. Ich muss auf jeden fall noch drauf achten, dass der zugewiesene Wert für die Position und der Wert den die Variable "Charakter X Mod Typ 1" haben, das gleiche sind, das wäre ja sonst sinnlos. ^^' Mein Problem sind die viele Möglichkeiten die es gibt, und mir fällt gerade kein Weg ein, wie ich das am besten "sequenziere" (falls man das so nennt). Ich hab grad 15 Minuten in die Leere gestarrt, aber in meinem Hirn tut sich nix.

    Die möglichen Verzweigungen:
    für 1 Charakter: 3 Modtypen, a 9 Slots, mit jeweils 9 möglichen Mods

    3*9*9 = 243 Forks ^^ - Ich bin mir sicher, dass man das irgendwie sequenzieren kann, aber ich weiß grad nicht wie. Auf sonstige Logikfehler, die ich evtl eingebaut habe, soll man mich bitte auch aufmerksam machen. Ich hoffe, man hat mich verstanden.

  7. #7
    ...ich bin ehrlich, ich bin immer noch nicht sicher, dass ich ganz verstehe, was exakt deine Frage ist.

    Jetzt mal rein theoretisch würde ich es so machen:
    Du hast 27 Variablen pro Char, quasi die "Liste der erlernten Skills". Außerdem hast du eine Liste mit allen möglichen erlernbaren Skills - bspw. in einem Txt-File, in den Comments, in der Skill-Sektion der Database, wie auch immer - Hauptsache, du hast irgendwo diese Zahl-Skill-Zuordnung. Jeder Skill hat eine Zahl zwischen 1 und 99, so hast du viel Platz, um später noch neue Skills dazuzudichten. Diese Zahl nenne ich jetzt einfach mal Skill-ID.
    Wenn dein Char einen Skill lernt trägst du die Skill-ID des neu-erlernten Skills in diese 27er-Liste ein, entweder an die nächste freie Stelle, an einen fixen Platz... wie du magst. Den Schritt wirst du nicht ganz automatisieren können und den musst du halt jedes Mal ausführen, wenn dein Char einen Skill lernt. Darüber hinaus würde ich nun Gebrauch von der o.g. Möglichkeit machen, mehrere Werte in einer Variable zu speichern, bspw. indem du dann zu der ID "+ (Skill-Lv * 100)" hinzufügst. So hast du nun eine Liste wo vermerkt ist, welche Skills dein Char kann und auf welchem Level diese Skills bei ihm sind.

    Was das Ausrüsten betrifft kannst du nun entweder eine neue Variable erstellen, ich würde aber auch da noch abkürzen: Wenn ein Char einen Skill lernt (und ihn nicht automatisch ausrüsten soll), multiplizierst du die oben angegebene Formel noch mit -1. So kannst du nun ganz einfach abfragen, ob ein Parameter in deiner Liste > 0 ist - wenn ja, dann ist das der Skill, den dein Char ausgerüstet hat. So hast du ziemlich viel Flexibilität mit sehr wenigen Variablen.

    Was die Anzeige betrifft würde ich den Spaß nun komplett automatisieren (Achtung, Pseudocode incoming):
    Annahme: Mod1, Typ1 liegt bei (0|0), Spalten liegen 100px auseinander, Zeilen 20px. Die Skill-Liste ist unter V0100 - V0126 gespeichert. Das Skill-Lvl steht 20px rechts neben dem Skillnamen.

    Code:
    <> Set Var [0001:Mod_X] = 0
    <> Set Var [0002:Mod_Y] = 0
    <> Set Var [0003:Mod_Pointer] = 0
    <> Set Var [0004:Pic_Pointer] = 0
    <> Set Var [0005:Skill_Lv] = 0
    
    //Variablen 0100 - 0126 enthalten die Skill-Liste
    
    <>BEGIN LOOP
      <>V[0004] = V[0003]
      <>V[0004] + 100
      <>V[0004] = V[V[0004]]
      <>V[0005] = V[0004]
      <>V[0005] / 1000
    
      // X-Koordinate anpassen
      <>V[0001] = V[0003]
      <>V[0001] mod 9
      <>V[0001] * 20
    
      // Y-Koordinate anpassen
      <>V[0002] = V[0003]
      <>V[0002] mod 3
      <>V[0002] * 100
    
      // Skillnamen anzeigen
      <>V[0004] mod 1000
      <>If V[0004] > 0
        <> (Zeige Bild für ausgerüsteten Skill an Pos(V0001|V0002))
      :ELSE CASE
        <> V[0004] * (-1)
        <> (Zeige Bild für nicht ausgerüsteten Skill an Pos(V0001|V0002))
      :END CASE
    
      // Skill-Lvl Anzeigen
      <>If V[0005] < 0
        <>V[0005] * (-1)
      :END CASE
      <>V[0001] + 20
      <>Show Picture (Skillnummer_[V0005], Pos(V0001|V0002))
    
      // Fertig?
      <>V[0003] + 1
      <>If V[0003] > 27
        <>Break Loop
      :END CASE
    
    END LOOP
    Dieser Code sollte dir dann eine 3x9-Tabelle generieren in der die Skills angezeigt werden, ihre Skilllevel (die Position der Ziffern dafür lässt sich dann ja anhand der Koordinaten für den Skillnamen bestimmen (oder umgekehrt, was dir lieber ist)), und der ausgerüstete Skill bekommt ein besonderes Bild.

    Wenn du nun durchnavigierst kannst du ja schauen, an welcher Position ist die Auswahl (again, 0-26) und dir dann wie in dem Beispiel ausgeben lassen, welcher Skill da hinterlegt ist, ob er ausgerüstet ist, wie stark er ist. Soll ein ausgerüsteter Skill abgelegt werden multiplizierst du mit (-1), umgekehrt ebenso. Bloß nicht-ausgerüstete Skills die auch so bleiben sollen dürfen halt das Vorzeichen nicht wechseln.
    Wenn der Spieler nun eine Zahlentaste drückt, schaust du einfach, in welcher Spalte er sich befindet, ermittelst daraus, an welcher Stelle der Liste er ist... und zack, kannste dir wieder ausgeben lassen, welcher Skill das ist usw. Dabei solltest du aber besser bei 0 anfangen zu zählen, das macht das ganze etwas simpler und sollte dann per ((9 * SPALTE) + ZAHL - 1) gehen - bist du in Spalte 0 und drückst 1, kommt da ((9*0)+1-1) = 0 raus, bei Spalte 2, Taste 9: ((9*2)+9-1) = (18+8) = 26. Da addierst du 100 (oder was immer bei dir zutrifft) um die Variablen-ID zu bekommen und - zack - weißt du wieder welcher Skill, wie stark, ausgerüstet ja/nein.
    Wenn du übrigens einfach dann bei 0200-0226 die Liste für Char 2 hast, kannst du das ganze Script auch für Char 2 verwenden - musst bloß statt +100 dann halt +200 rechnen. Das kannst du ja in eine Variable packen, dann musst du nichtmal das Script copy&paste-n für weitere Chars.

    Das einzige, was definitiv nicht geht und nicht gehen wird, ist, im Nachhinein dann die Skill_ID zu ändern. Du kannst die Reihenfolge der Anzeige ändern und alles, aber die ID muss gleich bleiben. Daran macht das System ja fest, welches Bild angezeigt wird und dann später auch, was der Skill eigentlich tut. Wenn du aber bloß die Sortierung ändern willst kannst du das vorab tun, wenn du einmal die Skill-Liste entsprechend belegst.

    Geändert von BDraw (11.01.2018 um 01:14 Uhr)

  8. #8
    Deine Ausführungen klingen verheißungsvoll und ich verstehe sie sogar über weite Strecken. Ich muss nur noch mehrmals drüber lesen und es irgendwie ausprobieren, ggf. nachfragen.

  9. #9
    (sorry, Doppelpost)

    Das mit dem mehrere Werte in einer Variable speichern, erscheint mir inzwischen sehr verlockend. Bisher ist das ja nur der Skill-Level, aber die Position könnte man da durchaus auch noch mit unterbringen.
    Ich stelle es mir als 2 Stellen vor, die 1. für die Position, die 2. für den Level:
    Mod aaa: 10
    Mod bbb: 20
    Mod ccc: 30

    Das wäre quasi der Ausgangszustand, den ich zu Beginn des Spiels festlegen würde und welcher die Position der Mods festlegt. Durch ändern der 1. Stelle, kann ich die Position bestimmen. Bei fortlaufendem Lernen würde dann aus der 2. Stelle eine 1, 2 etc. werden.
    Das wäre das, was du als „Liste“ meinst, allerdings bin ich mir nicht sicher, warum du eine Liste von erlernten und erlernbaren Skills unterscheidest. Diese hier kann ja beides enthalten

    Ich bin mir nicht sicher, warum du hier *100 rechnest:
    [quote]ID "+ (Skill-Lv * 100)" [quote]

    Damit die Zahl 4 Stellen hat?

    Ich habe übrigens nicht vor, den Skill-Level anzuzeigen. Die Zahl, die man bei dem gif sieht, ist ja die zugehörige Taste, die man zum Ausrüsten drückt.
    Das einzige, was mir gerade vorschwebt, was man evtl noch in dieser Variable speichern könnte, wäre der MP-Verbrauch. Aber das überlege ich mir vlt später nochmal, ich will erstmal diese Variante hinbekommen.

    Ich verstehe diesen Part nicht ganz:
    Code:
    <>V[0004] = V[0003]
      <>V[0004] + 100
      <>V[0004] = V[V[0004]]
      <>V[0005] = V[0004]
      <>V[0005] / 1000
    1. Befehl: Okay, die Variable Pic Pointer holt sich die aktuelle Mod bzw. Stelle, die bearbeitet wird, aus der Variable Mod Pointer, welche in jeder Runde +1 gerechnet wird.

    2. Befehl: Okay, +100 weil die Variablen da anfangen.

    3. Befehl: Das scheint irgendein geläufiger Ausdruck aus der Programmierung zu sein, den ich aber nicht kenne. ^^

    4/5. Befehl: Okay, ich glaube, das erübrigt sich, weil ich den Skill-Level wie gesagt gar nicht anzeigen will.


    Ich rattere mich langsam durch. Das ist wirklich umso anstrengender, je mehr Pointer und Gedöhns da vorkommen.
    Besonders aussichtsreicht erscheint es mir auch, damit gleich alle Charaktere abdecken zu können.

  10. #10
    Die Position speichern hat aber für dich keinen Mehrwert, da du ja trotzdem wissen musst, welche Variable du überhaupt referenzieren musst. Du müsstest also am Ende dennoch irgendwo die ID der Skill-Variable speichern - und hättest dann wieder nichts gewonnen.
    Du müsstest dann ALLE Skill-Variablen einzeln durchgehen und schauen, wo die sind - wenn du später Skills hinzufügst musst du das jedes Mal anpassen und wenn es mehr als 27 Skills sind hast du auch mehr abfragen als nötig. Andersherum, die einzelnen Positionen durchgehen und schauen "Welcher Skill liegt da?" ist da effizienter.

    Einfacher ist, wenn du erstmal überlegst, was du an Konstanten hast - das wären deine 3*9 Felder, die irgendwie belegt oder nicht belegt sind. Da die konstant sind, kannst du die als Ausgangspunkt nehmen und dann halt den dynamischen Part eintragen, nämlich, was denn in dem Slot drinsteckt. Und da du die ID der Variablen dieser Felder kennst und die einmal am Stück irgendwo im Maker einrichten kannst (bspw. 100-126) kannst du das dann automatisch mit Pointern machen und sparst dir die ganzen Abfragen von Hand.

    Wenn du die Skills dagegen abfragst anstatt der Felder musst du wieder von Hand in die Abfragen wenn du was hinzufügst - und kannst das auch nicht mehr so schön automatisieren, da die IDs dann ja vermutlich nicht mehr gleichmäßig verteilt sein werden.

    Zitat Zitat von IndependentArt Beitrag anzeigen
    Das wäre das, was du als „Liste“ meinst, allerdings bin ich mir nicht sicher, warum du eine Liste von erlernten und erlernbaren Skills unterscheidest. Diese hier kann ja beides enthalten
    ? Tue ich nicht. Ob ein Skill erlernt wurde kann man zum Teil der Skill-Variable machen: Wenn der Skill-Lvl = 0 ist bzw die ganze Variable 0, ist der Skill nicht erlernt. Oder du fügst den Skill erst bei Erlernen der Liste hinzu, das geht auch - bis dahin ist die Variable ja per default 0.

    Du brauchst bloß eine Liste pro Char, da dir sonst die verfügbaren Ziffern ausgehen, und eine "Masterliste", damit du selbst den Überblick über deine selbst-vergebenen Skill-IDs behältst.

    (EDIT: Aaah, ich glaube ich weiß, was du meinst. Ich ging davion aus, dass nicht erlernte Skills bei dir auch nicht angezeigt werden sollen, daher schrieb ich, dass die Skill-ID erst bei erlernen eingetragen wird. Kann man aber auch zu Beginn eintragen und einfach Level auf 0 setzen oder so.)

    Zitat Zitat von IndependentArt Beitrag anzeigen
    Ich bin mir nicht sicher, warum du hier *100 rechnest:
    Zitat Zitat
    ID "+ (Skill-Lv * 100)"
    Damit die Zahl 4 Stellen hat?

    Ich habe übrigens nicht vor, den Skill-Level anzuzeigen. Die Zahl, die man bei dem gif sieht, ist ja die zugehörige Taste, die man zum Ausrüsten drückt.
    Das einzige, was mir gerade vorschwebt, was man evtl noch in dieser Variable speichern könnte, wäre der MP-Verbrauch. Aber das überlege ich mir vlt später nochmal, ich will erstmal diese Variante hinbekommen.
    Ja. Wenn du einfach den Skill-Level addierst trennst du die Ziffern ja nicht mehr voneinander, sprich, du würdest die ursprüngliche, bereits vorhandene Zahl verfälschen. Wenn die Skill-ID = 12 ist und der Level 2, dann wäre 12+2=14. Das bekommst du so aber nie wieder auseinander. 12+(2*100) = 12 + 200 = 212 dagegen schon: Die Hundertserstelle (2) ist das Level, die Zehner- und Einerstelle (12) die ID.

    Den Skill-Level hatte ich jetzt mal in die Variable mitaufgenommen, damit du dort alle Infos hast - kannst es natürlich aus der Anzeige raus lassen. Wie gesagt, kannst den höchstens auch nutzen um abzufragen, ob ein Skill erlernt wurde - ist der Level = 0, kann der Char den Skill nicht, oder so.

    Zitat Zitat von IndependentArt Beitrag anzeigen
    Ich verstehe diesen Part nicht ganz:
    Code:
    <>V[0004] = V[0003]
      <>V[0004] + 100
      <>V[0004] = V[V[0004]]
      <>V[0005] = V[0004]
      <>V[0005] / 1000
    1. Befehl: Okay, die Variable Pic Pointer holt sich die aktuelle Mod bzw. Stelle, die bearbeitet wird, aus der Variable Mod Pointer, welche in jeder Runde +1 gerechnet wird.

    2. Befehl: Okay, +100 weil die Variablen da anfangen.

    3. Befehl: Das scheint irgendein geläufiger Ausdruck aus der Programmierung zu sein, den ich aber nicht kenne. ^^

    4/5. Befehl: Okay, ich glaube, das erübrigt sich, weil ich den Skill-Level wie gesagt gar nicht anzeigen will.
    Mal aufgedröselt:
    1. Setze Pic Pointer auf die Nummer des Felds, bei dem wir sind
    2. +100, damit der Pic-Pointer nun die ID der Variable hat, die unserem Feld zugeordnet ist
    3. Setze die Pic-Pointer Variable auf den Inhalt der Variable, deren ID im Pic-Pointer momentan gespeichert ist - wenn Picpointer also = 100 ist und Variable 100 = 5, wäre der Picpointer nun = 5.
    4./5. Befehl liest nun den Skill-Level aus, was ich so oder so tun würde, einfach um zu gucken, ob der Char den Skill überhaupt kann.

    Geändert von BDraw (11.01.2018 um 23:49 Uhr)

  11. #11
    Danke für die weiteren Erklärungsversuche. ^^

    Zitat Zitat
    Du hast 27 Variablen pro Char, quasi die "Liste der erlernten Skills". Außerdem hast du eine Liste mit allen möglichen erlernbaren Skills
    Das hörte sich für mich so an, als gäbe es 2 Listen. Und ich stolpere über die Formulierung „der erlernten Skills“, weil es so klingt, als hätte der Charakter diese von Anfang an schon alle gelernt, aber so meinst du es nicht, weil du ja später auch schreibst, dass der Status gelernt oder nicht aus dem Level hervorgeht.
    Ich glaube, was ich gerade zum ersten Mal verstanden hab ist: Die 27 Variablen tragen gar nicht den Namen der Skills, sondern sind quasi zunächst „leer“, oh Mann. ^^'

    Okay, ich glaube, ich verstehe jetzt erst deinen vorherigen Post richtig, sorry.

    Zitat Zitat
    Aaah, ich glaube ich weiß, was du meinst. Ich ging davion aus, dass nicht erlernte Skills bei dir auch nicht angezeigt werden sollen,
    Das ist so auch korrekt. Nicht erlernte Skills ergeben eine Lücke, wie man bei dem .gif in der mittleren Spalte sieht. Ich fand zwar die Möglichkeit interessant, dass man sie mit deinem Skript auch aufrutschen lassen könnte, aber sie sollen eigentlich feste Plätze haben. Deswegen muss ich wohl beim Anzeigen der Pictures auch noch prüfen, ob der Skill-Level größer 0 ist.

    Um mal ein wenig konkreter zu werden, hab ich versucht, das ganze nachzubauen. Es sollte sich um einen Klon deines Skripts handeln, das heißt, ich habe nichts großartig eingefügt, was ich jetzt der Meinung bin, was ich noch brauche. Ich will erstmal möglichst nur diese Arbeitsweise verstehen …
    Das einzige, was ich noch eingefügt habe, ist die Picture ID Variable, damit auch die Bilder fortlaufend angezeigt werden.
    Achja, und den Skill-Level hab ich weggelassen, weil mir das jetzt zum testen unerheblich schien.
    Meine Skill-Liste hab ich in der Database angelegt:

    Ich hab ein bisschen mehr Platz gelassen, weil ich mir die Möglichkeit offen halten wollte, doch noch eine maximale Anzahl von 12 auszureizen.

    Dementsprechend hab ich dem Charakter auch 36 mögliche Plätze zugewiesen:


    Ich hab bei einem anderen Test-Event auch Werte angegeben, aber wenn ich das richtig sehe, ist das nicht zwingend erforderlich, damit das Skript zumindest eine Tabelle anzeigt.

    Hier ist der Code:


    Und das ist das Ergebnis ^^


    Ich habe den Verdacht, mit deinen Formeln für X und Y stimmt was nicht. Das würde ich dich bitten, mal zu prüfen. Ich habe mich auch versucht in die Formel reinzudenken, aber konnte mir noch nicht so recht vorstellen, wie sie funktionieren sollte. Offenbar definieren die Modulo-Befehle ja irgendwie die Zeilen und Spalten, was ich auch schon wieder eine höchst erstaunliche, fast magische Angelegenheit finde. ^^
    Ich meine, ich bin sicher, du hast dir was dabei gedacht, aber vielleicht ist ja doch ein Denkfehler drin.

    Ich konnte durch verändern des Multiplikators schon den Zeilenabstand beeinflussen. Allerdings hatten die Pictures immer diesen Versatz, also sie waren nie wirklich untereinander.

    Ich weiß, es ist vielleicht etwas zäh, aber ich bin sicher, wir bekommen das hin. ^^
    Damit würden aus bisherigen 9 Common Events bei mir 1-2 werden.

  12. #12
    Zitat Zitat von IndependentArt Beitrag anzeigen
    Danke für die weiteren Erklärungsversuche. ^^

    Das hörte sich für mich so an, als gäbe es 2 Listen. Und ich stolpere über die Formulierung „der erlernten Skills“, weil es so klingt, als hätte der Charakter diese von Anfang an schon alle gelernt, aber so meinst du es nicht, weil du ja später auch schreibst, dass der Status gelernt oder nicht aus dem Level hervorgeht.
    Ah - ja, ich sprach von zwei Listen, aber nur eine davon im Maker. Die eine Liste, die Teil deines Codes ist, legt fest, welcher Platz der 9x3-Tabelle welchen Skill beinhaltet. Die andere Liste, die du in der Database, in deinem Notizbuch oder auf ner Papierserviette haben kannst, ist einfach für dich, damit du irgendwo eine Übersicht hast, welche Skill-ID welchem Skill zugeordnet ist.

    Zitat Zitat von IndependentArt Beitrag anzeigen
    Das ist so auch korrekt. Nicht erlernte Skills ergeben eine Lücke, wie man bei dem .gif in der mittleren Spalte sieht. Ich fand zwar die Möglichkeit interessant, dass man sie mit deinem Skript auch aufrutschen lassen könnte, aber sie sollen eigentlich feste Plätze haben. Deswegen muss ich wohl beim Anzeigen der Pictures auch noch prüfen, ob der Skill-Level größer 0 ist.
    Der Maker unterstützt ja mittlerweile das anzeigen von Pics mittels Pointern, sprich, du nennst deine Bilder "Skill_0000", "Skill_0001", usw. und legst dann per Variable fest, welche Zahl am Ende abgerufen werden soll. Wenn du nun "Skill_0000" leer lässt (also einfach ein komplett transparentes Bild zeigst) brauchst du so wirklich bloß für nicht-erlernte Skills die Variable auf 0 lassen oder mittels "wenn Skill_Lv = 0" die PicID auf 0 zu setzen. Oder du machst die Abfrage vorher und zeigst einfach gar kein Picture an, wenn der SkillLvl = 0 ist, das ist sogar noch etwas performanter.

    Bei dem Rest muss ich nun raten, da das Anhangs-System des Forums seit einer ganzen Weile schon kaputt ist. Lad Bilder am besten extern hoch, mir wird hier nichts angezeigt ^^" Ich kann dir also nicht genau sagen, was bei dir nicht klappt.

    Bei X und Y hatte ich tatsächlich nen Denkfehler, man braucht mod nur bei einer von beiden Berechnungen und auch entweder die Spalten- oder die Zeilenanzahl:

    00 01 02
    03 04 05
    06 07 08
    09 10 11
    12 13 14
    15 16 17
    18 19 20
    21 22 23
    24 25 26

    Für die Spaltenzahl:
    Zelle mod Spaltenzahl = Spalte
    2 mod 3 = 2
    3 mod 3 = 0
    17 mod 3 = 2

    Für die Zeilenzahl:
    Zelle / Spaltenzahl = Zeile
    2 / 3 = 0
    3 / 3 = 1
    17 / 3 = 5

    (Du kannst auch von oben nach unten zählen anstatt von links nach rechts wie hier, wenn dir das besser passt, du musst dann bloß statt mit der Spaltenzahl anstatt mit der Zeilenzahl rechnen.) Wichtig ist hier, dass das Ergebnis von 0 beginnt zu zählen, die Zeilen- bzw. Spaltenzahl aber von 1 gezählt werden muss (mod 0 bzw. /0 würde Probleme geben). Wenn dir das zu verwirrend ist, kannst du das Ergebnis auch +1 rechnen, aber das läuft aufs selbe hinaus - wichtig ist, dass du dir da ein System überlegst und selbst den Durchblick behältst.
    Wenn wir nun wissen, in welcher Zeile oder Spalte wir sind, ist es ja kein Problem, die Koordinaten zu ermitteln, wenn diese gleichmäßig verteilt sind:

    Offset + (Abstand * Faktor)

    Offset ist, wo das ganze Anfängt, Abstand wäre bspw. der Zeilen- oder Spaltenabstand, Faktor wäre deine aktuelle Zeile oder Spalte.

    EDIT:
    Wenn du sowas häufiger brauchst kann ich dir Excel (oder ein anderes Tabellenkalkulationsprogramm) ans Herz legen - da kannst du dir das einmal schön visuell darstellen und dann einmal dir eine ganze Liste erstellen, wo deine das Programm anhand deiner Formeln für jede Zelle Zeile und Spalte bestimmen soll. So kannst du ausprobieren, ob deine Formeln das ausspucken, was du dir vorstellst, ehe du es im Maker baust.

    Geändert von BDraw (13.01.2018 um 14:27 Uhr)

  13. #13
    Ehrlich gesagt verzweifel ich immer noch ein wenig daran und bekomme es nicht konstruiert.
    Sei so gut und schreibe mir bitte nochmal die Formel für X und Y unserer Mustertabelle auf, damit ich einfach mal Code und das was optisch passiert, in meinem Gehirn vernetzen kann. Und zwar von oben nach unten gezählt. Ich denke ja das macht Sinn, weil die Mod-Typen auch spaltenweise angeordnet sind.
    Btw: Das was du als Offset bezeichnest, müsste ich am Ende dazu addieren oder? Ich verstehe das so, dass ich damit die Tabelle nicht mehr bei (0;0) sondern zB (50;50) anfangen lassen kann, was ungefähr meinen vorherigen Koordinaten entspricht.

  14. #14
    Genau! Offset ist quasi die Startposition bei Zelle 0. Was den Code für Zeile und Spalte angeht, wäre es bei folgender Tabelle wie folgt:

    00 09 18
    01 10 19
    02 11 20
    03 12 21
    04 13 22
    05 14 23
    06 15 24
    07 16 25
    08 17 26

    Und nun die Formeln mit einigen Tests bei Zeilenzahl = 9 und Spaltenzahl = 3:
    Zelle Spalte Zeile
    Formel Zelle mod Zeilenzahl Zelle / Zeilenzahl
    0 0 0
    1 1 0
    2 2 0
    5 5 0
    10 1 1
    17 8 1
    26 8 2

    Und diese Zeile- bzw. Spaltenzahl multiplizierst du nun mit deinem Zeilen- bzw. Spaltenabstand und addierst den Onset (a.k.a. die Verschiebung).

    Wie gesagt, im Zweifel fix in Excel nachbauen, da kann man sowas ganz wunderbar austesten und bemerkt auch, ob man Denkfehler hat.

    Geändert von BDraw (13.01.2018 um 23:08 Uhr)

  15. #15
    Hey,
    dachte, ich melde mich heute mal mit dem ersten wirklichen Durchbruch. ^^



    Optik steht erstmal in den Grundzügen. Morgen mache ich mich dann an die Bedienung usw.

    Die Schrift muss ich halt mit einzelnen Forks anzeigen, weil das Textplugin auch nicht erlaubt, auf eine Datenbank oder sowas zuzugreifen. Höchstens auf die Database, aber der Aufwand hier ist auch überschaubar. Das würde wieder kompliziert werden mit englischen Namen etc.
    Besonders stolz bin ich aber, dass ich es auch hinbekommen habe, die "Tastennummer" mit einem einzigen write_text Befehl anzuzeigen, weil ich herausgefunden habe, dass man die ID da auch "pointen" kann. Eigentlich hätte ich das wissen können, aber ich habs noch nie ausprobiert.

    Deinen Credit-Eintrag hast du dir auf jeden Fall gesichert, BDraw. ^^ Also vielen Dank.

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •