Eine ganz persönliche Challenge

Es gibt 20 Antworten in diesem Thema, welches 2.624 mal aufgerufen wurde. Der letzte Beitrag (25. Juni 2024 um 15:40) ist von Tobias.

  • An Sylvester nimmt man sich manchmal was für das kommende Jahr vor. So auch ich: Für das Jahr 2023 hatte ich mir eine Challenge gestellt: Ich hatte mir (mit Gimp) ein Bild gemalt und die Challenge bestand darin, dieses Bild auf dem C64 pixelgenau darzustellen (hier vergrößert dargestellt):

    Bitte melde dich an, um diesen Anhang zu sehen.

    Und weil das ja noch nicht reicht, hatte ich mir zudem noch die Zusatzaufgabe gestellt, dass das Bild im Text-Modus eingebettet sein soll, so wie die Bilder bei Pirates, am Besten mit einem Tool, das das vollautomatisch (oder zumindest halbautomatisch) macht. Dann könnte man ein Spiel programmieren und diese Bilder dort einbauen. Wie gesagt, Pirates hat mich da sehr inspiriert.

    Ganz grob war also das Ziel sowas, wie in folgender Grafik (Fotomontage):

    Bitte melde dich an, um diesen Anhang zu sehen.

    Wie soll das mit den limitierten Grafik-Möglichkeiten des C64 gehen? Zum einen kann man die acht Sprites nutzen, um Pixel, die sich durch Zeichensatzgrafik nicht darstellen lassen, zu ergänzen. Zum anderen ist mit Raster-Tricks vieles möglich, was man sich ohne nie hätte träumen lassen...

    Nun bin ich kein Typ, der am zweiten Januar seine Sylvester-Vorsätze schon wieder vergessen hat. Ich habe mich mehrfach in diesem Jahr an dieser Aufgabe versucht. Jetzt ist das Jahr fast rum und ich möchte zum Abschluss meine Ergebnisse hier vorstellen. Und weil mir das zu viel ist, wenn ich alles auf einmal poste, habe ich beschlossen, jeden Tag ein bisschen was zu schreiben, bis Sylvester. Dann ist die Zeit reif für neue Vorsätze...

    PS: In der ursprünglichen Variante der Challenge war die Schrift am unteren Rand deutlich einfacher (einfarbig mit Schatten). Es stellte sich aber heraus, dass das keine Herausforderung war, weshalb ich diese nachträglich nochmal etwas schwieriger gemacht hatte.

  • Als erstes hatte ich mir mal angeschaut, wie gut man das ohne Sprites und Raster-Tricks hinbekommt, also nur unter Verwendung von Zeichen. Soll ja nicht so sein, dass da hinterher jemand ankommt und sagt: "Das hättest du mit PETSCII-Grafiken aber einfacher haben können!" :whistling:

    Und da stellte sich dann gleich mal die Frage, was heißt eigentlich "gut" in diesem Zusammenhang. Im habe mich, Coder der ich bin, dafür entschieden, einfach die richtigen Pixel zu zählen. Je mehr Pixel korrekt sind, desto besser. Das ist natürlich nicht ideal. Es macht ja schon einen Unterschied, ob man ein grünes Pixel durch ein hellgrünes oder eine lilanes ersetzt. Aber dafür müsste man ein besseres ästhetisches Gespür dafür haben, als ich das habe. (Es würde mich allerdings schon interessieren, was dabei rauskäme. Wenn also jemand Lust dazu hat, das mal auszuprobieren, nur zu!)

    Ich hab' mir ein PHP-Programm geschrieben (siehe Anhang), das einfach alle Möglichkeiten durchrechnet und dann das beste Ergebnis ausgibt. Die nachfolgende Tabelle zeigt die Ergebnisse:

    Was?ErgebnisRichtige Pixel
    PETSCII (Zeichensatz 1, einfarbig)Bitte melde dich an, um diesen Anhang zu sehen.4499/6400 (70,30%)
    PETSCII (Zeichensatz 2, einfarbig)Bitte melde dich an, um diesen Anhang zu sehen.4479/6400 (69,98%)
    PETSCII (Zeichensatz 1, mehrfarbig)Bitte melde dich an, um diesen Anhang zu sehen.4344/6400 (67,88%)
    PETSCII (Zeichensatz 2, mehrfarbig)Bitte melde dich an, um diesen Anhang zu sehen.4329/6400 (67,64%)
    Eigener Zeichensatz, einfarbigBitte melde dich an, um diesen Anhang zu sehen.4707/6400 (73,55%)
    Eigener Zeichensatz, mehrfarbigBitte melde dich an, um diesen Anhang zu sehen.4869/6400 (76,08%)
    Nur schwarzer HintergrundBitte melde dich an, um diesen Anhang zu sehen.3594/6400 (56,16%)

    Bei den PETSCII-Grafiken schneidet Zeichensatz 1, einfarbig, am besten ab. Meines Wissens ist das auch die Variante, die bei PETSCII-Grafikern am beliebtesten ist.

    Mit eigenem Zeichensatz hingegen ist die Multi-Color-Version besser: Über 3/4 der Pixel sind hier schon korrekt. (Wobei man dazu sagen muss, dass über die Hälfte aller Pixel im Original-Bild ohnehin schwarz sind und bei einem komplett schwarzen Bild auch schon mehr als die Hälfte der Pixel richtig ist...)

    Aber so richtig überzeugt das alles noch nicht. (Und deshalb hatte ich hier auch nie Programme geschrieben, die das Ergebnis auf dem C64 wirklich anzeigen.) Ohne Sprites und ohne Rastertricks kommt man einfach nicht all zu weit...

    Im Anhang findet ihr das PHP-Programm (Dateiendung auf .php ändern) und die RTI-Datei, die dem übergeben werden muss (Dateiendung auf .rti ändern). Das RTI-Format hab' ich mir selber überlegt - einfach mit Texteditor anpassen, wenn man eigene Bilder damit berechnen will.

  • Also war der logische nächste Schritt, Sprites dazu zu nehmen. Aber das ist gar nicht so einfach. Es gibt einfach unglaublich viele Parameter, an denen man stellen und schrauben kann: Soll das Sprite doppelte Breite haben, Multi-Color oder einfarbig sein, vor oder hinter dem Hintergrund, und auch die Nummer des Sprites und natürlich auch die Position spielen wichtige Rollen. Und dann gibt es noch die Farben, von denen die beiden MC-Farben ja gleich für alle Sprites gelten.

    Mit dem PHP-Programm war es nicht mehr möglich, das alles durchzusuchen, weshalb ich das Programm nochmal in Java nachprogrammiert habe. Aber auch da dauert es viel zu lange, alle Möglichkeiten durchzurechnen.

    Ich hab' stattdessen einen Greedy-Algorithmus programmiert, der versucht, so schnell wie möglich ein gutes Ergebnis zu erreichen, indem in jedem Schritt so viele Pixel, wie möglich korrigiert werden: Zuerst der Reihe nach mit den Sprites, dann Auffüllen mit dem Zeichensatz. Und das wird so lange wiederholt, bis keine Verbesserung mehr möglich ist. Zuletzt wird jedes einzelne falsche Pixel noch angeschaut, ob man das nicht doch noch durch eine Kombination richtig kriegen kann. Falls ja, geht der Prozess wieder von Vorne los.

    Das dauert ziemlich lange, denn das wird nicht nur einmal durchlaufen, sondern für jede Kombination der beiden Sprite-MC-Farben einmal. Um es etwas zu beschleunigen, hat das Programm eine Heuristik einprogrammiert, die eine Auswahl unter den Farben trifft und dann nur noch diese bei den Sprite-MC-Farben ausprobiert (und zudem auch den Bereich der Sprites etwas einschränkt). Damit liefert das Programm innerhalb einiger Minuten ein Ergebnis.

    Apropos Ergebnis: Das Ergebnis kann man sich jetzt als ACME-Datei ausgeben lassen. Die kann man compilieren und dann direkt das Ergebnis im C64 bewundern. (Datei mit ,8,1 laden und dann mit SYS16384 starten.)

    Und das kommt dabei raus:

    Nur Sprites:
    Mit Heuristik:Bitte melde dich an, um diesen Anhang zu sehen.4997/6400 (78,08%)
    Ohne Heuristik:Bitte melde dich an, um diesen Anhang zu sehen.5005/6400 (78,20%)
    Sprites und Zeichensatz:
    Mit Heuristik:Bitte melde dich an, um diesen Anhang zu sehen.5846/6400 (91,34%)
    Ohne Heuristik:Bitte melde dich an, um diesen Anhang zu sehen.5851/6400 (91,42%)

    Also immerhin schon über 90% der Pixel richtig. Und vermutlich ginge sogar noch etwas mehr, denn das Programm berechnet ja nicht unbedingt das Optimum.

    Bei den Varianten mit Sprite und Zeichen enthält der Kreis in der Mitte schon 15 der 16 Farben. Lediglich hellgrau fehlt noch. Auch der Regenbogen ist schon gut zu erkennen. Nur bei der Schrift am unteren Rand happert es doch noch sehr, was daran liegt, dass dort keine Sprites zum Einsatz kommen, die nutzen im oberen Teil mehr.

    Im Anhang findet ihr das Programm (Endung in .java ändern) und alle benötigten Dateien. Bitte beachtet, dass sich das Format der rti-Datei gegenüber der Version für das PHP-Programm leicht geändert hat. Die .asm-Dateien sind automatisch generierte ACME-Dateien (ggfs. Endung auf .a ändern).

  • Wobei die Bilder bei Pirates einfach nur Zeichensatzgrafik waren. Hatte mal einen Bitte melde dich an, um diesen Link zu sehen. und irgendwie eigene Bilder in das Format konvertiert. Die Tools die ich für die Konvertierung benutzt (geschrieben?) habe, sind mir aber irgendwie abhanden gekommen.

  • Jetzt war es an der Zeit, die (Raster-)Trick-Kiste zu öffnen. Schnell wurde mir dabei klar, dass die Position des Bildes am rechten Rand hierfür eher ungünstig ist, weil man das 9. Bit der Sprite-X-Koordinaten regelmäßig zusätzlich ändern muss. Das kostet viele Taktzyklen und die sind oft ohnehin schon sehr rar. Ich hab' das Bild deswegen nach links verschoben, da hat man dieses Problem nicht. ^^

    Ich hab' dann damit begonnen, die Grafik zeilenweise von oben nach unten umzusetzen. Am Anfang ging das noch ziemlich gut, wurde aber immer schwieriger. Als ich bei einer Badline angekommen war, dachte ich zuerst, da geht es nicht mehr weiter (in Badlines ist der Prozessor ausgeschaltet und man kann deswegen dort keine Raster-Tricks anwenden). Ich hab' aber dann doch noch eine Möglichkeit gefunden, wie man sich darüber retten kann.

    Ein paar Zeilen später, so um Zeile 28 herum, war dann aber Ende: Ein Pixel im Regenbogen wollte einfach nicht die richtige Farbe haben. Der Grund dafür war, dass ich einige Zeilen zuvor die beiden MC-Farben für die Zeichen falschrum belegt hatte. Hätte ich diese vertauscht wäre es gegangen. (Eine davon zählt als Vordergrund, die andere als Hintergrund und das macht einen Unterschied, wenn die Sprites hinter den Zeichen verschwinden sollen.)

    Also bin ich wieder zurück, habe die Farben vertauscht, was natürlich auch bedeutet, die ganzen Grafiken anzupassen. Danach tauchten aber neue Fehler auf. Ich hab' zuerst noch versucht, diese ebenfalls zu beheben, hab' dann aber irgendwann einfach aufgegeben. Zu oft musste man dafür zurückspringen und dort nochmal etwas ändern, was dann wiederum weitere Änderungen nach sich zog. Ohne ein Programm, das einem dabei hilft, kommt man so nicht weiter.

    Das, was nach den vielen Rettungs-Versuchen noch erhalten ist, sieht so aus:

    Bitte melde dich an, um diesen Anhang zu sehen.

    Auch wenn ich mit diesem Ansatz erst mal gescheitert war, fühlte sich das Ganze trotzdem recht gut an. Ich hatte zu dem Zeitpunkt den Eindruck, dass es möglich sein könnte, die Grafik (zumindest fast) vollständig hinzubekommen.

    PS: Falls sich jemand über dieses türkis-lila-blaue Etwas wundert :huh:, was da unten dran hängt: Das ist ein gemultiplextes Sprite, bei dem der Spritedatenzeiger noch nicht angepasst worden ist; das wäre in der nächsten Zeile passiert, dann wäre es wieder weg gewesen...

    Im Anhang findet ihr noch die drei ACME-Dateien (Anhänge wieder in .a umbenennen).

  • Sehr cool. Super dokumentiert. Quelltext muss ich mir mal später angucken. Was ich gerade noch nicht verstanden habe ist, warum bei den letzten Bildern die Schrift so verschwommen ist. Wurde der Zeichensatz durch deinen Algorithmus auch verändert und daher wurden die Buchstaben verändert?

  • warum bei den letzten Bildern die Schrift so verschwommen ist.

    Multi.

    Arndt

    GoDot C64 Image Processing
    Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen.
    Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen.

  • Was ich gerade noch nicht verstanden habe ist, warum bei den letzten Bildern die Schrift so verschwommen ist. Wurde der Zeichensatz durch deinen Algorithmus auch verändert und daher wurden die Buchstaben verändert?

    GoDot hat es ja schon geschrieben: Ich verwende hier den MultiColor-Mode für die Zeichen, damit ich mehr Farben zur Verfügung habe. In einer späteren Version (kommt übermorgen) habe ich bei allen Bildschirmfarben das Bit 3 auf 0 gesetzt, dann ist die Schrift (trotz Multicolor-Mode) wieder richtig lesbar, allerdings dunkel- statt hellblau. (Pirates benutzt diesen Trick übrigens auch.)

  • Die neue Idee sah so aus: Ich schreibe einfach ein Programm, welches für jedes Pixel alle Möglichkeiten ausrechnet, wie man dieses richtig setzen kann. Dann muss man diese Möglichkeiten nur noch richtig kombinieren, sodass alle Pixel am Ende richtig sind. Sowas nennt man Constraint-Satisfaction-Problem. Damit hatte ich schon mal zu tun gehabt und auch mit CSP-Solvern, die sowas lösen.

    Also hab' ich mich dran gemacht, so eine lange Liste von Constraints zu berechnen und dann einen Solver dafür zu schreiben. Das war viel Arbeit und lange Zeit auch ohne sichtbaren Erfolg, denn man kann den Solver ja erst richtig schreiben, wenn man alle Constraints berechnet hat und derer gibt es viele.

    Als dann alles fertig war, kam die große Enttäuschung: Das Programm war noch nicht mal in der Lage, die ersten 8 Zeilen der Grafik in halbwegs brauchbarer Zeit zu berechnen.

    Also hab' ich den Solver optimiert, die Reihenfolge der Constraints angepasst, Heuristiken implementiert und so fort, bis die ersten 8 Zeilen endlich funktionierten.

    Aber bei den nächsten 8 Zeilen hängte sich das Programm wieder auf, und so langsam gingen mir die Ideen aus, wie man das noch weiter verbessern hätte können. Von Hand war ich da deutlich effektiver gewesen.

    Vielleicht mit einem Hybrid-Ansatz? Also so: Ich gebe dem Programm einen Hinweis, was es ausprobieren soll, und das Programm macht das dann? Ich hab' auch das probiert, aber es hat noch schlechter geklappt.

    Nach einem Monat Arbeit blieb die Erkenntnis: Das war der berühmte Satz mit X... :S

  • Hast du den Solver auf dem C64 programmiert und rechnen lassen oder auf einen PC, um dann die Lösung (später) auf den C64 zu übertragen?

  • Hast du den Solver auf dem C64 programmiert und rechnen lassen oder auf einen PC, um dann die Lösung (später) auf den C64 zu übertragen?

    Angesichts dieser früheren Aussage ist von letzterem auszugehen:

    Mit dem PHP-Programm war es nicht mehr möglich, das alles durchzusuchen, weshalb ich das Programm nochmal in Java nachprogrammiert habe. Aber auch da dauert es viel zu lange, alle Möglichkeiten durchzurechnen.

    [...]

    Im Anhang findet ihr das Programm (Endung in .java ändern) und alle benötigten Dateien.

  • Hast du den Solver auf dem C64 programmiert und rechnen lassen oder auf einen PC, um dann die Lösung (später) auf den C64 zu übertragen?

    Das Programm war komplett in Java auf dem PC. Ich denke, auf dem C64 sind derartige Berechnungen nicht mehr in sinnvoller Zeit möglich, selbst wenn man alles in Maschinensprache schreibt. Es ist ja selbst auf dem PC eine ziemliche Herausforderung.

    PS: Aaaaaaah, die Anzahl meiner Beiträge in diesem Forum hat die 8-Bit-Grenze gesprengt. :cry:

  • PS: Aaaaaaah, die Anzahl meiner Beiträge in diesem Forum hat die 8-Bit-Grenze gesprengt. :cry:

    Ist ok, erst ab 65536 Beiträgen wirst Du automatisch ins Amigaforum verschoben ^^

    ────────────────────────────────────────────────────────────
    Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen.
    ────────────────────────────────────────────────────────────

  • Der Versuch mit der Handarbeit hatte mir gut gefallen. Am Ende hatte ich dort das Gefühl, dass eines der großen Probleme die vielen Farben im Inneren des Kreises waren. Ab das überhaupt gehen kann, so einen Kreis mit allen 16 Farben?

    Ich wollte also erst mal kleinere Brötchen backen und nur den inneren Kreis angehen. Das hat fast :!: geklappt:

    Bitte melde dich an, um diesen Anhang zu sehen.

    Auf den ersten Blick sieht es so aus, als wäre das perfekt, aber wenn man es sich genau anschaut, stellt man fest, dass da ein weißes Pixel (ziemlich weit rechts) eigentlich hellgrau sein müsste. Es wäre zwar im Prinzip möglich gewesen, das grau zu färben, aber leider kam mir da eine Badline an der Stelle dazwischen, weshalb ich den Trick in der Zeile darüber nicht wiederholen konnte. Eine andere Möglichkeit hatte ich nicht gefunden, war aber mit dem Ergebnis trotzdem ziemlich zufrieden. Das sieht ja doch schonmal nach was aus.

    Entsprechend motiviert machte ich mich an den Text unterhalb des Kreises. Das war dann auch der Zeitpunkt, wo ich beschlossen hatte, den Text etwas komplizierter zu machen, weil das Original völlig trivial umzusetzen war. :sleeping: Aber auch der neue Text ging gut durch. Das Ergebnis sieht so aus:

    Bitte melde dich an, um diesen Anhang zu sehen.

    Ich hatte hierfür einen besonderen Trick verwendet: Drei Sprites werden als schwarze Schablonen benutzt, die nur den Platz für die farbigen Pixel frei lassen. Da der Text nicht die ganze Breite des Bildes benutzt, passt das gerade noch so eben. Mit den restlichen Sprites und den Zeichen konnte ich dann die Farben ergänzen. Fast. Es stellte sich nämlich heraus, dass es eine Farbe zu wenig war. Für die ließ sich aber die Hintergrundfarbe nutzen: Das Schwarz wird ja nicht mehr benötigt, weil das schon die Sprites liefern. Also wird in jeder Zeile die Hintergrundfarbe kurz auf blau und dann wieder auf schwarz zurückgewechselt.

    Bei einem Pixel konnte ich dabei sogar ausnutzen, dass der Wechsel der Hintergrundfarbe nicht in der ersten Spalte eines Zeichens erfolgt, sondern erst in der zweiten. Den Unterschied (beim letzten R unten links) sieht man beispielsweise, wenn man den VICE mit x64 statt x64sc startet. Ersterer macht das nämlich falsch. :X

    Ist es jemandem aufgefallen? Der Text im vorigen Bild war nicht an der richtigen Stelle: Im Original geht der über einer Badline, was bedeutet, dass man in der Zeile die Hintergrundfarbe nicht ändern kann.

    Das hat mich auf eine neue Idee gebracht: Wenn man das ganze Bild etwas nach unten verschiebt, sollte das mit dem hellgrauen Pixel im Mittelkreis kein Problem mehr sein und gleichzeitig ist der Text dann ohne Badlines.

    Nach einigem Rumtüfteln bin ich zu dem Ergebnis gekommen, dass ein Verschieben um fünf Zeilen optimal ist. Und wenn wir gerade schon beim Verschieben sind: Vier Pixel nach rechts hat auch noch ein paar Vorteile beim inneren Kreis, und dürfte auch beim Regenbogen hilfreich sein, weil man zusätzliche Zeichen verwenden kann, die unterschiedlich gefärbt sein können.

    Also habe ich kurzerhand den inneren Kreis und die Schrift nochmal neu gerastertrickt. (Diesmal brauchte ich allerdings den coolen Trick, der im x64 nicht funktioniert, nicht mehr. 8)) Dafür war der innere Kreis und die Schrift perfekt.

    Fehlte also nur noch der Regenbogen. Den müsste man doch jetzt einfach noch ergänzen, das hatte im ersten Handarbeits-Versuch doch auch schon recht gut geklappt. Und vielleicht muss man dann am unteren Ende des Regenbogens ein paar Kompromisse eingehen, aber mit so einem Ergebnis wäre ich schon zufrieden...

    Allerdings war das alles andere als einfach, den Regenbogen da noch drum rum zu legen. Oberhalb des Kreises ging das noch recht gut, man musste nur die dadurch verschwindenden Taktzyklen exakt ausrechnen. Aber sobald der Regenbogen mit dem inneren Kreis zu interagieren begann, wurde es schwierig, weil jede kleine Änderung einen Rattenschwanz an Korrekturen nach sich zog, damit der Kreis weiterhin so perfekt blieb. Ich hab' das dann schnell wieder aufgegeben. Das Ergebnis bis hierhin sieht so aus:

    Bitte melde dich an, um diesen Anhang zu sehen.

    Fehlt doch eigentlich nicht mehr viel, oder?

    PS: Das ergibt: 6032/6400 (94,25%)

  • Das, was ich gestern gepostet habe, war der Stand vom April. Und es war auch der Stand an Weihnachten. :whistling: Private und berufliche Veränderungen hatten dafür gesorgt, dass Raster-Trick-Bilder nur noch das zweitwichtigste in meinem Leben waren. Erst jetzt, zu Weihnachten fielen sie mir wieder ein.

    Als ich das erste Posting in diesem Thread verfasst hatte, dachte ich noch, ich würde hier einfach einen Ausblick geben, was man noch so machen könnte. Aber dann, als ich das Java-Programm für die Bilder ohne Raster-Tricks nochmal laufen lassen hab', kam mir eine Idee:

    Wenn ich das Programm immer nur für je 24 Zeilen laufen lasse, und diese dann einfach mit einem Sprite-Multiplexer aneinanderklebe, dann hätte ich sicherlich eine ziemlich gute Näherung. Die könnte man dann noch durch Rastertricks etwas verfeinern.

    Das Problem war nur, dass das "aneinanderkleben" nicht so gut funktionierte, wie gedacht. Da müssen in einer Zeile etwa 30 Register umprogrammiert werden. Mit gut zureden schafft der Prozessor in der Zeit aber gerade mal etwa 8 Register. Aber: Eigentlich brauchte ich nur eine Lösung für die Zeilen, in denen Regenbogen und Kreis gleichzeitig vorkommen. Den Rest hatte ich ja bereits.

    Also hab' ich folgendes gemacht: Für diesen schwierigen Abschnitt habe ich mir mit dem Java-Programm eine gute Annäherung berechnen lassen. So sieht die aus:

    Bitte melde dich an, um diesen Anhang zu sehen.

    Danach hab' ich vorne einen Anfang dran programmiert. Das war nicht ganz so einfach, wie man denken könnte, weil ich ja auch hier das Problem mit den 30 Registern hatte. Aber wenn man von Anfang an auf die richtige Register-Kombination hinarbeitet, dann sind viele davon beim Wechsel bereits richtig und müssen nicht mehr geändert werden, zudem gab es auch ein paar, die erst zwei oder drei Zeilen später geändert werden mussten, das hat es auch etwas vereinfacht.

    Dann hab' ich den obigen Streifen drangepappt und den dann etwas verbessert; hauptsächlich habe ich dabei die Sprites aufgefüllt, die ja durch den Multiplexer jetzt in allen 24 Zeilen vorhanden waren und nicht nur in 21.

    Dann hab' ich den unteren Teil des Kreises nochmal neu geschrieben. Das war notwendig, weil ich, hätte ich das alte Programm benutzt, hier sonst schon wieder das Problem mit den 30 Registern gehabt hätte. Aber inzwischen habe ich genug Übung, dass das in ein paar Stunden erledigt war. Die Schrift konnte ich in wenigen Minuten einfach drankopieren, da ist genug Platz dazwischen um die 30 Register einfach neu zu setzen.

    Zu dem Zeitpunkt, am Freitag morgen, waren noch 82 Pixel falsch. Den Rest der Zeit habe ich dann damit zugebracht, mal hier ein Pixel, mal da zwei zu korrigieren. Oft musste ich dabei für die Korrektur zweier Pixel in Kauf nehmen, dass an einer anderen Stelle eines falsch wurde; was aber natürlich trotzdem ein kleiner Fortschritt ist. Manchmal ging auch ein Plan nicht auf und die Anzahl der richtigen Pixel war nach einer Änderung wieder angestiegen, dann musste ich alles wieder zurücksetzen (da war ich ganz froh, dass ich mit GIT gearbeitet habe).

    So nach und nach ging die Anzahl der falschen Pixel aber runter. Ganz würde ich diese nicht wegkriegen, das war mir klar, weil ich keine Lösung für die hellgrünen Pixel im Regenbogen finden konnte. Auch an einigen anderen Stellen war offensichtlich, dass man da ohne gigantischen Aufwand nichts mehr würde machen können.

    Am Ende fehlten noch 64 Pixel. Die Zahl kam mir irgendwie bekannt vor, das konnte kein Zufall sein... Also hab' ich's dabei belassen, auch wenn ich vermute, dass man noch ein paar Pixel hätte korrigieren können.

    Und so sieht das Ergebnis aus:

    Bitte melde dich an, um diesen Anhang zu sehen.

    Final Score: 6336/6400 (99,00%)

    Yeah, 99% geschafft! Darauf trink ich jetzt erst mal was, was aber nicht ganz 99% hat... :drunk:

    Im Anhang findet ihr wieder die ACME-Dateien. Für die Final-Version habe ich auch noch eine PRG-Datei hochgeladen, für Leute, die ACME nicht haben. Diese Datei nach wie vor mit ,8,1 laden und mit SYS16384 das Programm starten.

  • Das finde ich eine schöne Aufgabe, einen sehr schönen Bericht und ein Super-Ergebnis! Danke fürs Teilen! Ich programmieren ja auch gern für den Cevi, unter anderem gerade weil es von vornherein mehr oder weniger sinnlos ist. Das nimmt finde ich den Erfolgsdruck raus. Daher kann ich sehr gut die Motivation hinter so einer selbstgestellten Challenge nachvollziehen. :thumbup:

    ────────────────────────────────────────────────────────────
    Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen.
    ────────────────────────────────────────────────────────────

    Einmal editiert, zuletzt von Claus (31. Dezember 2023 um 13:44)

  • Falls es jemanden interessiert, habe ich die einzelnen "Layer" mal noch aus dem Bild extrahiert:

    Sprite 0Bitte melde dich an, um diesen Anhang zu sehen.
    Sprite 1Bitte melde dich an, um diesen Anhang zu sehen.
    Sprite 2Bitte melde dich an, um diesen Anhang zu sehen.
    Sprite 3Bitte melde dich an, um diesen Anhang zu sehen.
    Sprite 4Bitte melde dich an, um diesen Anhang zu sehen.
    Sprite 5Bitte melde dich an, um diesen Anhang zu sehen.
    Sprite 6Bitte melde dich an, um diesen Anhang zu sehen.
    Sprite 7Bitte melde dich an, um diesen Anhang zu sehen.
    ZeichenBitte melde dich an, um diesen Anhang zu sehen.
    HintergrundBitte melde dich an, um diesen Anhang zu sehen.

    Man muss dabei aber beachten, dass man die jetzt nicht einfach so aufeinander legen kann. Zum Teil sind die Sprites Hintergrundsprites, und das auch oft wegen der Rastertricks nur teilweise. Mit Hintergrundsprites gibt es ganz merkwürdiges Verhalten. Beispielsweise kann ein Vordergrund-Sprite ein Zeichen verdecken, wenn man dann aber vor dieses Sprite ein Hintergrund-Sprite legt, welches das Vordergrund-Sprite verdeckt, sieht man plötzlich wieder das Zeichen hinter dem Vordergrund-Sprite...

  • wenn man dann aber vor dieses Sprite ein Hintergrund-Sprite legt, welches das Vordergrund-Sprite verdeckt, sieht man plötzlich wieder das Zeichen hinter dem Vordergrund-Sprite...

    Das steht schon Bitte melde dich an, um diesen Link zu sehen. beschrieben, hehe... :smile:

    Darf ich dir auch meinerseits meinen großen Dank für den Blog über deinen Parforceritt durch die VIC-Darstellungshölle entrichten? Ich habe deinen Erfahrungsbericht mit dem allergrößten Vergnügen verfolgt und finde es eigentlich schade, dass es nun (allerdings so erfolgreich!) zu Ende ist damit! Gratulation zu deinem Durchhaltevermögen und deiner Erzählkunst, du hast hoffentlich noch viel mehr solcher Projekte auf Lager? :wink:

    Auf ein in diesem Sinne wunderbares Jahr 2024!

    Arndt

    GoDot C64 Image Processing
    Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen.
    Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen. - Bitte melde dich an, um diesen Link zu sehen.

  • Das steht schon Bitte melde dich an, um diesen Link zu sehen. beschrieben, hehe... :smile:

    Rat' mal, wer das da reingeschrieben hat... :D

    du hast hoffentlich noch viel mehr solcher Projekte auf Lager? :wink:

    Bislang nicht. Aber wer weiß schon, was die Zukunft so alles bringt...