Logikers Vintage Computing Christmas Challenge 2024

[skr]

Logiker (macht auch ATASCI I- und AMSCII-Competition) hat die Aufgabe für die diesjährige Weihnachts-Challenge veröffentlich:

http://logiker.com/Vintage-Computing-Ch ... lenge-2024

Es geht darum, das vorgegebene Bild 1:1 mit einem selbsgeschriebenem Programm "nachzubauen". Das kann in einer beliebigen Sprache ein, ich selber habe BASIC genommen und werde auch keinen Blumentopf gewinnen. Denn: Es gibt etwas zu gewinnen!

Logiker2024Challenge.png (111.02 KiB) 1879 mal betrachtet

Also haut in die Tasten, noch kann man die Beiträge gar nicht einreichen, aber ich denke mal, die Deadline kommt schnell.

Edit: Ich bin da nicht von selber drauf gekommen, sondern durch die Ankündigung bei AtariAge: https://forums.atariage.com/topic/37708 ... challenge/

Und ja: Mein Programm ist schon fertig.

[skr]

Heute ist der letzte Tag, um etwas einzureichen. Wer also unter Weihnachtslangeweile leidet, kann noch in die Tasten hauen.

Ich habe noch schnell eine zweite Version in Atari BASIC eingereicht, die auf for ... next Schleifen und Sprüngen basiert.

[Kveldulfur]

Hallo!

Ich habe am Wettbewerb nicht teilgenommen. Naja, die Bedingungen konnte ich mir noch übersetzen lassen, aber das Formular, was man ausfüllen musste...
Egal, ich habe auch nicht selbst etwas programmiert, sondern ChatGPT antreten lassen
Wie bei vielen Anfängern, benötigte auch ChatGPT ein wenig Unterstützung und einen Stups in die richtige Richtung.
Zum Schluß kam dabei dieses Programm heraus:

Code: Alles auswählen

    ORG $0600              ; Startadresse des Programms
    JSR CLEAR_SCREEN       ; Bildschirm löschen
    LDA #2
    STA $54
    JSR DRAW_HEADER        ; Muster 1: '\O/' zentriert
    JSR DRAW_LINE_BLOCK    ; Muster 2: '+--------+--------+'
    JSR DRAW_BODY_BLOCK    ; Muster 3: 8x '    !        !        !'
    JSR DRAW_LINE_BLOCK    ; Muster 2 wiederholen
    JSR DRAW_BODY_BLOCK    ; Muster 3: 8x '    !        !        !'
    JSR DRAW_LINE_BLOCK    ; Muster 2 noch einmal
    JMP *                  ; Endlosschleife

CLEAR_SCREEN:
    LDA #$7D               ; Clear Screen Befehl
    STA $342               ; Kommando-Byte (ICCOM) für IOCB 0
    JSR CIO_CALL           ; CIO aufrufen
    RTS

SET_CURSOR:
    STA $55                ; Spalte setzen (Low-Byte von COLCRS)
    LDA #0
    STA $56
    RTS

DRAW_HEADER:
    LDA #18                ; Spalte für Header (\O/)
    JSR SET_CURSOR         ; Cursor positionieren
    LDA #<HEADER_TEXT      ; Adresse des Header-Textes (Low-Byte)
    LDY #>HEADER_TEXT      ; Adresse des Header-Textes (High-Byte)
    JSR PRINT_TEXT         ; Ausgabe auf den Bildschirm
    RTS

DRAW_LINE_BLOCK:
    LDA #10                 ; Spalte für Linie
    JSR SET_CURSOR         ; Cursor positionieren
    LDA #<LINE_TEXT        ; Adresse der Linie (Low-Byte)
    LDY #>LINE_TEXT        ; Adresse der Linie (High-Byte)
    JSR PRINT_TEXT         ; Zeile ausgeben
    RTS

DRAW_BODY_BLOCK:
    LDA #8                 ; 8 Wiederholungen für Muster 3
    STA COUNTER            ; Zähler setzen
DRAW_BODY_LOOP:
    LDA #10                ; Spalte für Body
    JSR SET_CURSOR         ; Cursor positionieren
    LDA #<BODY_TEXT        ; Adresse des Textes (Low-Byte)
    LDY #>BODY_TEXT        ; Adresse des Textes (High-Byte)
    JSR PRINT_TEXT         ; Zeile ausgeben
    DEC COUNTER            ; Zähler dekrementieren
    BNE DRAW_BODY_LOOP     ; Wiederholen, solange Zähler > 0
    RTS

PRINT_TEXT:
    STA $344               ; Textadresse ins IOCB (Low-Byte)
    STY $345               ; Textadresse ins IOCB (High-Byte)
    LDA #$09               ; Put Text Record (CIO-Befehl)
    STA $342               ; Kommando ins IOCB
    LDA #40                ; Maximale Länge der Zeile (40 Zeichen)
    STA $348               ; Textlänge ins IOCB
    LDX #0                 ; IOCB Nummer 0
CIO_CALL:
    JSR $E456              ; CIO aufrufen
    RTS

HEADER_TEXT:
    .BYTE '\O/', $9B

LINE_TEXT:
    .BYTE '+--------+--------+', $9B 

BODY_TEXT:
    .BYTE '!        !        !', $9B 

COUNTER:
    .BYTE 0                ; Speicherplatz für den Zähler

	run $0600

Der Code ist alles andere als optimiert, funktioniert aber

Grüße
Janko

[skr]

Da nur ein Programm pro Maschine/Sprache zugelassen war, habe ich meinen ersten Versuch wieder zurückgezogen, der sieht so aus:

Code: Alles auswählen

10 POKE 82,10:GRAPHICS 0:POKE 752,1:? :?
20 FOR I=0 TO 10:READ A:? CHR$(A);:NEXT I:?
30 FOR X=0 TO 1:FOR I=0 TO 18:READ B:? CHR$(B);:NEXT I:?
40 FOR I=0 TO 7:FOR J=0 TO 18:READ C:? CHR$(C);:NEXT J:? :RESTORE 120:NEXT I:RESTORE 110:NEXT X
50 RESTORE 110:FOR K=0 TO 18:READ E:? CHR$(E);:NEXT K
99 GOTO 99
100 DATA 32,32,32,32,32,32,32,32,92,79,47
110 DATA 43,45,45,45,45,45,45,45,45,43,45,45,45,45,45,45,45,45,43
120 DATA 33,32,32,32,32,32,32,32,32,33,32,32,32,32,32,32,32,32,33

Aber irgendwie fand ich das mit den Data-Zeilen doof und meine finale Einreichung sieht ähnlich aus, wie Dein KI-Assembler-Code, nur eben in BASIC und mit deutlich weniger Zeilen (5)

Naja, die Bedingungen konnte ich mir noch übersetzen lassen, aber das Formular, was man ausfüllen musste...

Ja, das war nervig. Ich mache auch nicht beim "wer hat den kleinsten" (Code) mit sondern hatte den obigen Code _sehr_ ausführlich dokumentiert. Eher so als BASIC-Tutorial von mir Coding-Legastheniker für totale Anfänger. Kann ich bei Interesse mal aufhübschen und wegen mir fürs Magazin einreichen.

Anbei ein atr mit XDOS und dem Programm.

XMAS_skr_DOS.png (53.77 KiB) 1528 mal betrachtet

XMAS_skr_Listing.png (84.6 KiB) 1528 mal betrachtet

XMAS_skr_Result.png (46.5 KiB) 1528 mal betrachtet

[slx]

Hier meine Beiträge in Action!, Atari BASIC und Atari LOGO, letzteres "freestyle". Alle drei sind ausschließlich auf minimale Größe optimiert. Assembler habe ich probiert, bin aber mit eigenen Ideen, die direkt in den Bildschirmspeicher schreiben, an hartnäckigen Bugs gescheitert, die zu suchen ich vor Weihnachten nicht genug Zeit hatte. Lauffähig habe ich nur ein "Nicht-Programm" inspiriert von ein paar Bemerkungen von "kenjennings" auf AtariAge hinbekommen.


Zuerst habe ich es mit Action! probiert, aber da muss man doch recht "ordentlich" programmieren und kann die Befehle nicht abkürzen. Daher mit 144 Byte relativ lang. Ich habe überlegt, statt zwei Strings etwas kürzeres zu versuchen, aber mir ist nichts eingefallen, dass kürzer gewesen wäre als die eingesparten Strings. Wäre interessant, die "Formel-Lösung" in Action zu versuchen:

PARCEL.ACT source.png (106.16 KiB) 1472 mal betrachtet

PARCEL.ACT output.png (84.63 KiB) 1472 mal betrachtet

In Atari BASIC geht es schon deutlich schlampiger. Im Original sind die Leerzeichen noch eingespart, aber leider ist mir nicht eingefallen, dass man FOR auch noch abkürzen kann und auf die tolle Idee mit der Formel für das Zeichen bin ich auch nicht gekommen, daher immer noch 129 Bytes:

PARCEL.LST source code.png (6.45 KiB) 1472 mal betrachtet

PARCEL.LST output.png (87.34 KiB) 1472 mal betrachtet

Der Versuch in LOGO war interessant, weil ich da noch nie mehr als ein bisschen Turtle Graphics probiert hatte, aber auch da muss sauber geschrieben werden und es ist nicht viel abzukürzen. Mit Strings habe ich gar nicht erst angefangen sondern ein bisschen Kontrollstrukturen angeschaut und Turtle Graphics verwendet, daher nur "Freestyle" und mit 203 Bytes die längste Version.

LOGIK1.LOG listing.png (119.37 KiB) 1472 mal betrachtet

LOGIK1LOG output.png (57.35 KiB) 1472 mal betrachtet