[ERLEDIGT] Super Mario Advance 4 Paletten Berechnung

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • [ERLEDIGT] Super Mario Advance 4 Paletten Berechnung

    Hi Leute,

    ich habe ein kleines Problem mit den Paletten von SMA4. und zwar werden die irgendwie im Spiel nochmal anders Berechnet sodass ein einfaches copy & byteswitch & paste für die Palettensuche nicht funktioniert.

    habe mal ein Teil einer Palette extrahiert(1. R, 2. G, 3. B):

    Quellcode

    1. VBA APE Diff
    2. 247 => 239 -8
    3. 33 => 16 -17
    4. 41 => 25 -16
    5. 255 => 255
    6. 148 => 132 -16
    7. 0 => 0
    8. 255 => 255
    9. 214 => 197 -17
    10. 66 => 41 -25
    11. 107 => 82 -25
    12. 197 => 181 -16
    13. 66 => 41 -25
    Alles anzeigen


    Könnt Ihr mir sagen was hier vor sich geht?^^

    Gruß,
    Julian
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)

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

  • Ich nehme diese beiden Bytes, vertausche diese und rechne sie dann im APE um pbrd.co/18mv93g.
    Wenn ich allerdings die gleiche Farbe aus der Pal direkt im APE umrechne stehen da halt andere RGB Werte und der GBA-Farbcode stimmt auch nicht mit dem von VBA überein
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)
  • hmm komisch, kann mich noch dunkel an ein Pal Editing Tut erinnern wurde geschrieben dass die Bytes verkehrt herum im HexEdit gesucht werden müssen...
    Aber ich habe mal ein Bild gemacht damit Ihr versteht was ich meine:
    pasteboard.co/fg6oVR.png

    Edit: Keiner ne Idee was da genau passiert?

    Gruß,
    Julian
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)

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

  • Das ist die BG Palette von World 1-1.
    Die Pal selbst findest du bei Offset 0x21D880, falls nicht kannst du auch hiernach suchen:

    Quellcode

    1. 00000000FF7F815565765D0C1F021F17CA160000000000007F5B000000000000787FFF7F0000066E8A760E7F
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)
  • Ich habe dir hier mal einen Farbwert aufgeschlüsselt(Index basierend auf 0):

    Eintrag 3: 0x5DE3 - 0 10111 01111 00011 Wie dir der VBA schon sagt: Rot: 3 ; Grün: 15 ; Blau: 23, für RGB-Werte einfach mal mit 8 multiplizieren und du bekommst: Rot: 24 ; Grün: 120 ; Blau: 184. Wie das jetzt mit deiner Tabelle zusammenpasst musst du mir mal erklären, jedenfalls würde ich das so rechnen und auch APE tut das im Normalfall. Du hast wohl mit Little-Endian Werten gerechnet. Im VBA werden die Werte schon korrekt angezeigt, lediglich im Hex-Editor stehen sie "Byte-Verkehrt", einfach weil der Prozessor sie so lesen kann.

    Edit: Stimmt btw. auch nicht mit den oben angegebenen Hex-Werten überein... Ist aber die selbe Palette wie auf deinem ersten Screenshot.
  • Hallo Welt :)

    Dann möchte ich das Thema mal wieder aufgreifen :D (Falls ich, des alters halber, lieber einen neuen Thread starten soll bitte kurz info an mich)

    Ich konnte leider, auch nach genauerem hinsehen noch nicht herausfinden, was wie umgerechnet wird.

    Als Beispiel nach wie vor die oben genannte Palette und die Farbe 5D0C:


    In VBA wird daraus dann aber 149E (bzw. 9E14):



    Also habe ich hin und her getestet mit verschiedenen Werten:

    Quellcode

    1. Blau Grün Rot
    2. Eingabe: 00000 00000 00001
    3. Ausgabe: 00000 01011 00000
    4. Eingabe: 00000 00000 00010
    5. Ausgabe: 00000 10010 00000
    6. Eingabe: 00000 00000 01111
    7. Ausgabe: 00101 11010 00000
    8. Eingabe: 00101 11010 00000
    9. Ausgabe: 10010 00000 11001
    10. Eingabe: 10000 00000 00000
    11. Ausgabe: 00000 00100 00000
    12. Eingabe: 00001 00000 00000
    13. Ausgabe: 00000 00000 00110
    14. Eingabe: 00010 00000 00000
    15. Ausgabe: 00000 00000 01011
    16. Eingabe: 00100 00000 00000
    17. Ausgabe: 00000 00000 10010
    Alles anzeigen
    Und konnte feststellen dass die Eingabe bei der Ausgabe um 7 Bits nach rechts geschiftet werden.
    Soweit so gut. Allerdings kann ich mir die zusätzlichen 1-Bits wie im ersten Beispiel zu erkennen nicht erklären, könnt ihr da ein Muster erkennen?

    Danke für eure Hilfe.

    Viele Grüße,
    Julian
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)
  • Die Farbe 0x5D0C entspricht NICHT der Farbe 0x149E. Das heißt, dass vermutlich beim Laden der Palette noch irgendwelche Filter auf diese gelegt wurden oder aber die Palette die du da hast, stimmt einfach nicht mit der im RAM geladenen überein. In Pokemon Feuerrot z.B. wird für einige Wetter Effekte ein Alpha-Kanal zur Farbe Schwarz eingesetzt, um die Farben dunkler werden zu lassen.

    0x5D0C = 10111 01000 01100 zur Basis 2, wenn man das als RGB Tripel darstellt wäre das (22, 8, 12).
    0x149E = 00101 00100 11110 zur Basis 2, als RGB Tripel (5, 4, 30).

    Das scheint wenig Sinn zu ergeben. Allerdings ist vermutlich 0x5D0C LE encoded, also betrachten wir:
    0x0C5D = 00110 0010 11101 zur Basis 2, als RGB Tripel (6, 2, 29).

    Man könnte annehmen, dass hier ebenfalls ein Alpha-Kanal verwendet wird. Für einen Wert alpha aus [0, 1] errechnet sich das dann wie folgt für jede Farbkomponente c, wobei c entweder Rot, Blau oder Grün aus {0, .... 31} ist. Die Farbe, die ich drüberlege nenne ich einfach "over".

    c_neu = alpha * c_over + (1 - alpha) * c_alt

    Daraus bekommen wir also 3 Gleichungen mit 4 Unbekannten.

    30 = alpha * rot_over + 29 - alpha * 29
    4 = alpha * grün_over + 2 - alpha * 2
    5 = alpha * blau_over + 4 - alpha * 4

    Um das eindeutig zu lösen, bräuchte man noch ein exaktes Zeilenpaar (ich bin mir mit deiner Tabelle und ihrer Interpretation nicht 100% sicher, am besten gehst du so vor, wie beschrieben) und dein System ist mit 6 Gleichungen überbestimmt. Das System kannst du dann lösen um die Farbe over = (blau_over, grün_over, rot_over) und die Stärke des Kanals alpha zu errechnen. Anhand der solltest du konsistent alle Farben ineinander umrechnen können. Wenn das System sich allerdings nicht lösen lässt, liegt kein Alpha Blending vor. Dann muss man sehen...
    Wo war Gondor, als meine Klausurenphase begann?
  • @Wodka: Danke für deine Antwort

    Hier die Gleichungen (alpha = X, farbe_over = Y):
    Spoiler anzeigen


    Quellcode

    1. VBA Palette: 5DE3: 10111 01111 00011
    2. Hex-Editor: 8155 -> 5581: 10101 01100 00001
    3. X = 1, Y = 3;
    4. 3 = X * Y + 1 - X * 1
    5. X = 1, Y = 15
    6. 15 = X * Y + 12 - X * 12
    7. X = 1, Y = 23
    8. 23 = X * Y + 21 - X * 21
    9. VBA Palette: 7AA8: 11110 10101 01000
    10. Hex-Editor: 6576 -> 7665: 11101 10011 00101
    11. X = 1, Y = 8;
    12. 8 = X * Y + 5 - X * 5
    13. X = 1, Y = 21
    14. 21 = X * Y + 19 - X * 19
    15. X = 1, Y = 30
    16. 30 = X * Y + 29 - X * 29
    17. VBA Palette: 149E: 00101 00100 11110
    18. Hex-Editor: 5D0C -> 0C5D: 00011 00010 11101
    19. X = 1, Y = 30;
    20. 30 = X * Y + 29 - X * 29
    21. X = 1, Y = 4
    22. 4 = X * Y + 2 - X * 2
    23. X = 1, Y = 5
    24. 5 = X * Y + 4 - X * 4
    25. VBA Palette: 025F: 00000 10010 11111
    26. Hex-Editor: 1F02 -> 021F: 00000 10000 11111
    27. X = 0; Y = 31;
    28. 31 = X * Y + 31 - X * 31
    29. X = 1, Y = 18
    30. 18 = X * Y + 16 - X * 16
    31. X = 0, Y = 0
    32. 0 = X * Y + 0 - X * 0
    33. VBA Palette: 235F: 01000 11010 11111
    34. Hex-Editor: 1F17 -> 171F: 00101 11000 11111
    35. X = 0; Y = 31;
    36. 31 = X * Y + 31 - X * 31
    37. X = 1, Y = 26
    38. 26 = X * Y + 24 - X * 24
    39. X = 1, Y = 8
    40. 8 = X * Y + 5 - X * 5
    Alles anzeigen



    Daraus ergibt sich:
    alpha = Farbwert in [0, 31] dann 0 ansonsten 1
    farbe_over = Farbwert

    Aber wie bekomme ich nun aus der neuen Farbe die alte Farbe? (Ich muss ja irgendwie bei 3 = X * Y + 1 - X * 1 auf die 1 kommen :) )

    EDIT:
    Die Änderung ist immer gleich pro Farbwert, hier ein Mapping:

    Quellcode

    1. VBA => ROM
    2. 00000 => 00000 (+0)
    3. 00011 => 00001 (+2)
    4. 00100 => 00010 (+2)
    5. 00101 => 00011 (+2)
    6. 00110 => 00100 (+2)
    7. 01000 => 00101 (+3)
    8. 01001 => 00110 (+3)
    9. 01010 => 00111 (+3)
    10. 01011 => 01000 (+3)
    11. 01100 => 01001 (+3)
    12. 01101 => 01010 (+3)
    13. 01110 => 01011 (+3)
    14. 01111 => 01100 (+3)
    15. 10000 => 01101 (+3)
    16. 10001 => 01110 (+3)
    17. 10001 => 01111 (+2)
    18. 10010 => 10000 (+2)
    19. 10011 => 10001 (+2)
    20. 10100 => 10010 (+2)
    21. 10101 => 10011 (+2)
    22. 10110 => 10100 (+2)
    23. 10111 => 10101 (+2)
    24. 11000 => 10110 (+2)
    25. 11001 => 10111 (+2)
    26. 11010 => 11000 (+2)
    27. 11011 => 11001 (+2)
    28. 11100 => 11010 (+2)
    29. 11101 => 11011 (+2)
    30. 11101 => 11100 (+1)
    31. 11110 => 11101 (+1)
    32. 11110 => 11110 (+0)
    33. 11111 => 11111 (+0)
    Alles anzeigen
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)

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

  • Es geht um Super Mario Advance 4. (einfach nach "1190 - Super Mario Advance 4 - Super Mario Bros. 3 (E)(Menace)" googlen).

    Die Adresse der Palette ist 0x21D880. Die Palette wird in Welt 1 Level 1 verwendet.
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)
  • Wirklich viel Info hab ich jetzt zwar nicht, weil ich mich nicht lange damit beschäftigt habe, aber vielleicht findest du ja noch mehr raus...

    Wenn ich mich nicht vertan habe wird deine Palette hier geladen: sub_80B3024 - Es gibt noch eine zweite Stelle, wo zumindest ein Pointer auf deine Palette rumfliegt, den hab ich aber nicht untersucht. Es wird zuerst die Palette in den Speicher geholt:

    C-Quellcode

    1. cpu_fast_set(0x821D880, 0x2000000);

    Und anschließend "etwas", damit gemacht:


    C-Quellcode

    1. v0 = 0;
    2. do
    3. {
    4. word_2000000[v0] = manipulate_pal_maybe(word_2000000[v0], 0);
    5. word_2000000[v0 + 256] = manipulate_pal_maybe(word_2000000[v0 + 256], 1);
    6. v0 = (v0 + 1) & 0xFFFF;
    7. }
    8. while ( v0 <= 0xFF );
    Diese manipulate_pal_maybe habe ich noch nicht ordentlich dekompiliert, die macht aber recht konfuses Zeug:

    C-Quellcode

    1. unsigned int __fastcall manipulate_pal_maybe(int a1, int a2)
    2. {
    3. unsigned __int16 *v2; // r3
    4. if ( a2 << 16 )
    5. v2 = (unsigned __int16 *)&unk_8132EE4;
    6. else
    7. v2 = (unsigned __int16 *)&unk_8132DE4;
    8. return ((v2[32 * ((unsigned int)MEMORY[0x300378B] << 29 >> 30) + (((unsigned int)(a1 << 16) >> 26) & 0x1F)] << 26) | ((v2[32 * ((unsigned int)MEMORY[0x300378B] << 29 >> 30) + (a1 & 0x1F)] | 32 * (unsigned int)v2[32 * ((unsigned int)MEMORY[0x300378B] << 29 >> 30) + (((unsigned int)(a1 << 16) >> 21) & 0x1F)]) << 16)) >> 16;
    9. }
    Ich schätze mal, das wird so in etwa dein Übeltäter sein, hier wird einmal die komplette BG und OAM Palette mit irgendeinem Filter bearbeitet, je nachdem wird in "v2" ein anderer Wert geladen, und dann diese abstrus lange return Wurst ausgeführt.

    Happy Researching!

    ~Sturmvogel
    Wandering on Horizon Road
  • Kannst du mir eventuell noch sagen wie bzw. mit was unk_8132EE4 und unk_8132DE4 befüllt ist?

    EDIT: Ich habs :) Das sind Adressen im ROM (führende 8 weglassen) Ich forsche weiter, konnte die Funktionen auf jeden Fall nachbilden
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)

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

  • Wenn ich das richtig interpretiert habe ist das einfach nur so ein Array, bzw. 2 die direkt hinter einander liegen (Oder halt eines, dann wird im einen Fall einfach nur die zweite Hälfte geladen)


    Spoiler anzeigen

    Quellcode

    1. ROM:08132DE4 word_8132DE4 DCW 0, 2, 3, 4, 5, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE
    2. ROM:08132DE4 ; DATA XREF: manipulate_pal_maybe:loc_8007B70↑o
    3. ROM:08132DE4 ; ROM:off_8007BC4↑o
    4. ROM:08132DE4 DCW 0xF, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17
    5. ROM:08132DE4 DCW 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0
    6. ROM:08132DE4 DCW 3, 4, 5, 6, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x10
    7. ROM:08132DE4 DCW 0x11, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18
    8. ROM:08132DE4 DCW 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F
    9. ROM:08132DE4 DCW 0, 3, 4, 5, 6, 7, 9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF
    10. ROM:08132DE4 DCW 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x17
    11. ROM:08132DE4 DCW 0x18, 0x19, 0x19, 0x1A, 0x1B, 0x1B, 0x1C, 0x1D, 0x1E
    12. ROM:08132DE4 DCW 0x1F, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE
    13. ROM:08132DE4 DCW 0xF, 0x10, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
    14. ROM:08132DE4 DCW 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1E
    15. ROM:08132DE4 DCW 0x1F, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC
    16. ROM:08132DE4 DCW 0xD, 0xE, 0xF, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
    17. ROM:08132DE4 DCW 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E
    18. ROM:08132DE4 DCW 0x1F, 0, 3, 4, 5, 6, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE
    19. ROM:08132DE4 DCW 0xF, 0x10, 0x11, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
    20. ROM:08132DE4 DCW 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1D, 0x1E
    21. ROM:08132DE4 DCW 0x1E, 0x1F, 0, 3, 4, 5, 6, 7, 9, 0xA, 0xB, 0xC, 0xD
    22. ROM:08132DE4 DCW 0xE, 0xF, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16
    23. ROM:08132DE4 DCW 0x17, 0x17, 0x18, 0x19, 0x19, 0x1A, 0x1B, 0x1B, 0x1C
    24. ROM:08132DE4 DCW 0x1D, 0x1E, 0x1F, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB
    25. ROM:08132DE4 DCW 0xC, 0xD, 0xE, 0xF, 0x10, 0x10, 0x11, 0x12, 0x13, 0x14
    26. ROM:08132DE4 DCW 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D
    27. ROM:08132DE4 DCW 0x1E, 0x1E, 0x1F, 0x201, 0xC0B, 0x8891, 0x800, 0x8891
    28. ROM:08132DE4 DCW 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800
    29. ROM:08132DE4 DCW 0x8891, 0x800, 0x8895, 0x800, 0x8891, 0x800, 0x8891
    30. ROM:08132DE4 DCW 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800
    31. ROM:08132DE4 DCW 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891
    32. ROM:08132DE4 DCW 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800
    33. ROM:08132DE4 DCW 0x8891, 0x800, 0x8911, 0x800, 0x8891, 0x800, 0x8971
    34. ROM:08132DE4 DCW 0x800, 0x89ED, 0x800, 0x8891, 0x800, 0x8891, 0x800
    35. ROM:08132DE4 DCW 0x8891, 0x800, 0x8891, 0x800, 0x8A69, 0x800, 0x8AC9
    36. ROM:08132DE4 DCW 0x800, 0x8971, 0x800, 0x8B29, 0x800, 0x8891, 0x800
    37. ROM:08132DE4 DCW 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891
    38. ROM:08132DE4 DCW 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800
    39. ROM:08132DE4 DCW 0x8891, 0x800, 0x8891, 0x800, 0x8AC9, 0x800, 0x8891
    40. ROM:08132DE4 DCW 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800
    41. ROM:08132DE4 DCW 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891
    42. ROM:08132DE4 DCW 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800
    43. ROM:08132DE4 DCW 0x8891, 0x800, 0x8891, 0x800, 0x8891, 0x800, 0x8891
    44. ROM:08132DE4 DCW 0x800, 0x8891, 0x800, 0x8971, 0x800, 0x8B29, 0x800
    45. ROM:08132DE4 DCW 0x8A69, 0x800, 0x8971, 0x800, 0x8971, 0x800, 0xFFFF
    46. ROM:08132DE4 DCW 0xFFFF, 0xFFFE, 0xFFFF, 0x7FF, 0x7FFF, 0x7FDF, 0xFBFF
    47. ROM:08132DE4 DCW 0x7F7F, 0x7F7F, 0x7DF7, 0xEFBF, 0x7BDF, 0x7BDF, 0x77BB
    48. ROM:08132DE4 DCW 0xDDEF, 0x7777, 0x7777, 0x6EDD, 0xBB77, 0x6DB7, 0x6DB7
    49. ROM:08132DE4 DCW 0x5B6D, 0xB6DB, 0x5B5B, 0x5B5B, 0x5B5B, 0x5B5B, 0x5555
    50. ROM:08132DE4 DCW 0xAD6B, 0x5555, 0xAAAB, 0x5555, 0x5555, 0x2A55, 0x5555
    51. ROM:08132DE4 DCW 0x2A55, 0x2A55, 0x294A, 0x5295, 0x2525, 0x2525, 0x2492
    52. ROM:08132DE4 DCW 0x4925, 0x1249, 0x1249, 0x1122, 0x4489, 0x1111, 0x1111
    53. ROM:08132DE4 DCW 0x844, 0x2211, 0x421, 0x421, 0x208, 0x1041, 0x101
    54. ROM:08132DE4 DCW 0x101, 0x20, 0x401, 1, 1, 0, 1, 0, 0xFFFF, 0xFFE0
    55. ROM:08132DE4 DCW 0xFFDF, 0xFC00, 0xFBFF, 0xFBE0, 0xFBDF, 0, 1, 0x20
    56. ROM:08132DE4 DCW 0x21, 0x400, 0x401, 0x420, 0x421, 0x3178, 0x813, 0x3168
    57. ROM:08132DE4 DCW 0x813, 0x8000, 0x4000, 0x2000, 0x1000, 0x800, 0x400
    58. ROM:08132DE4 DCW 0x200, 0x100, 0x80, 0x40, 0x20, 0x10, 8, 4, 2, 1, 0x45BC
    59. ROM:08132DE4 DCW 0x14A5, 0x7FFF, 0x23F, 0x1D8, 0x136, 0x42FF, 0x3ABF
    60. ROM:08132DE4 DCW 0x2D9C, 0x5B3F, 0x6976, 0x50F0, 0x3C88, 0x136, 0x1D8
    61. ROM:08132DE4 DCW 0x23F, 0x45BC, 0x7FFF, 0x14A5, 0x92, 0x98, 0x9F, 0x215B
    62. ROM:08132DE4 DCW 0x261D, 0x36BE, 0x152F
    Alles anzeigen


    Der Name von dem Ding wird automatisch aus der Adresse generiert, du kannst also einfach im Hex Editor nachschauen was das für Daten sind.

    ~Sturmvogel
    Wandering on Horizon Road
  • Ich habe die Funktion zur Manipulation mal etwas entwirrt und in C# übersetzt:


    C-Quellcode

    1. long manipulate_pal_maybe(long byteWord)
    2. {
    3. long[] v2 = {
    4. 0x0000, 0x0003, 0x0004, 0x0005, 0x0006, 0x0008, 0x0009, 0x000A,
    5. 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010, 0x0011, 0x0011,
    6. 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019,
    7. 0x001A, 0x001B, 0x001C, 0x001D, 0x001D, 0x001E, 0x001E, 0x001F,
    8. };
    9. var a = (v2[(byteWord >> 10) & 0x1F] << 10);
    10. var b = (v2[(byteWord & 0x1F)] | 32 * v2[(byteWord >> 5 & 0x1F)]);
    11. return a | b;
    12. }
    Alles anzeigen

    Sieht aber auf den ersten Blick nach einer Falltür-Funktion aus :-/



    EDIT:
    So, hab mal ein kleines JavaScript geschrieben mit dem sich die Palette aus VBA easy umrechnen lässt:

    JavaScript-Quellcode

    1. // Einfach die Farben aus VBA 1:1 übernehmen und in die funktion schmeißen und dann kommen alle möglichen kombinationen raus
    2. console.log(calulatePalette('000000007FFF5DE37AA8149E025F235F230D'));
    3. function calulatePalette(paletteString) {
    4. var chunks = paletteString.match(/.{1,4}/g).map(function (chunk) {
    5. return convertColor(parseInt(chunk, 16));
    6. });
    7. return allPossibleStrings(chunks)
    8. }
    9. function allPossibleStrings(chunks, current, result) {
    10. var chunk = chunks.shift();
    11. var current = current || [];
    12. var result = result || [];
    13. for (i = 0; i < chunk.length; i++) {
    14. current.push(chunk[i]);
    15. if (chunks.length > 0) {
    16. allPossibleStrings(chunks, current, result);
    17. } else {
    18. result.push(current.slice().map(function (ichunk) {
    19. return ichunk.match(/.{1,2}/g).reverse().join('');
    20. }).join(' '));
    21. current.pop();
    22. }
    23. }
    24. return result;
    25. }
    26. function convertColor(find) {
    27. let map = {
    28. 0x00: [0x00],
    29. 0x03: [0x01],
    30. 0x04: [0x02],
    31. 0x05: [0x03],
    32. 0x06: [0x04],
    33. 0x08: [0x05],
    34. 0x09: [0x06],
    35. 0x0a: [0x07],
    36. 0x0b: [0x08],
    37. 0x0c: [0x09],
    38. 0x0d: [0x0a],
    39. 0x0e: [0x0b],
    40. 0x0f: [0x0c],
    41. 0x10: [0x0d],
    42. 0x11: [0x0e, 0x0f],
    43. 0x12: [0x10],
    44. 0x13: [0x11],
    45. 0x14: [0x12],
    46. 0x15: [0x13],
    47. 0x16: [0x14],
    48. 0x17: [0x15],
    49. 0x18: [0x16],
    50. 0x19: [0x17],
    51. 0x1a: [0x18],
    52. 0x1b: [0x19],
    53. 0x1c: [0x1a],
    54. 0x1d: [0x1b, 0x1c],
    55. 0x1e: [0x1d, 0x1e],
    56. 0x1f: [0x1f]
    57. };
    58. find = find.toString(16);
    59. let colorBits = padLeft(parseInt(find, 16).toString(2), 16, '0').substr(1).match(/.{1,5}/g);
    60. let blueMatches = map[parseInt(colorBits[0], 2)];
    61. let greenMatches = map[parseInt(colorBits[1], 2)];
    62. let redMatches = map[parseInt(colorBits[2], 2)];
    63. let results = [];
    64. for (let b = 0; b < blueMatches.length; b++) {
    65. for (let g = 0; g < greenMatches.length; g++) {
    66. for (let r = 0; r < redMatches.length; r++) {
    67. let binString =
    68. padLeft(blueMatches[b].toString(2), 5).toString() +
    69. padLeft(greenMatches[g].toString(2), 5).toString() +
    70. padLeft(redMatches[r].toString(2), 5).toString();
    71. let hexString = padLeft(parseInt(binString, 2).toString(16), 4, '0');
    72. results.push(hexString);
    73. }
    74. }
    75. }
    76. return results;
    77. }
    78. function padLeft(str, num, chr) {
    79. chr = chr || '0';
    80. while (str.length < num) str = chr + str;
    81. return str;
    82. }
    Alles anzeigen

    Werde das bei Gelegenheit noch in ein vernünftiges Programm übertragen

    Danke @Sturmvogel, somit kann das Thema endlich geschlossen werden :)
    Ich bin nicht vergesslich, in meinem Hirn werden nur Pointer zu den Leuten angelegt, auf die ich dann nur zurück greifen muss um die Information zu erlangen :)

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