Christmas Star - Revision history

Wil: /* Shortest BASIC entry for C64 */ fixed language

2023-01-07T16:37:27Z

‎Shortest BASIC entry for C64: fixed language

Wil: /* Shortest entry for C64 */ -> Shortest BASIC entry for C64

2023-01-01T23:06:57Z

‎Shortest entry for C64: -> Shortest BASIC entry for C64

Wil: /* Winning Entries */ rephrased to avoid overuse of winning - there was only one main contest

2023-01-01T22:49:53Z

‎Winning Entries: rephrased to avoid overuse of winning - there was only one main contest

Wil: /* The challenge */

2023-01-01T22:39:17Z

‎The challenge

Wil: /* 34 bytes version for C64 */ -> should be called 32 bytes version

2023-01-01T21:46:18Z

‎34 bytes version for C64: -> should be called 32 bytes version

Wil: /* Winning entry for C64 */

2023-01-01T21:44:51Z

‎Winning entry for C64

Wil: /* The challenge */ Program length measurement explanation.

2023-01-01T21:44:18Z

‎The challenge: Program length measurement explanation.

Serato: Added post deadline32 byte C64 version

2022-12-31T09:19:14Z

Added post deadline32 byte C64 version

Wil: /* The challenge */ minor language edit

2022-12-28T21:46:33Z

‎The challenge: minor language edit

Serato: Added Serato's 34 entry for C64

2022-12-28T20:50:07Z

Added Serato's 34 entry for C64

@@ Line 60: / Line 60: @@
 === Shortest BASIC entry for C64 ===
-While BASIC programmes sees to have a structural disadvantage for this kind of challenge, some entries in the spirit of oneliners are remarably compact.
+While BASIC programs seem to have a structural disadvantage for this kind of challenge, some entries in the spirit of oneliners are remarkably compact.
-The shortest BASIC entry for the C64 was submitted by Serato with 68 bytes tokenized code.
+The shortest BASIC entry for the C64 was submitted by Serato with 68 bytes of tokenized code.
 <syntaxhighlight lang="basic">

@@ Line 57: / Line 57: @@
 Serato's entry was provided with the following comments:
   <nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki>
 ==Optimized post-deadline versions==

@@ Line 27: / Line 27: @@
 Program length was measured as the shortest of source, file, or "real" code (excluding basic stub and file load address). For assembler programs started with SYS or call, typically filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.
-==Winning Entries==
+==Remarkable Entries==
-=== Winning entry for C64 ===
+=== Shortest entry for C64 ===
 The shortest entry for the C64 was submitted by Serato with 34 bytes (filesize 36 bytes):
 <syntaxhighlight lang="6502">

@@ Line 25: / Line 25: @@
 * mirror triangles
-Program length was measured as the minimum of (executable code minus file header, sourcecode). For assembler, the sourcecode version is always larger than the program, so the filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.
+Program length was measured as the shortest of source, file, or "real" code (excluding basic stub and file load address). For assembler programs started with SYS or call, typically filesize minus load address (=file header) is the relevant number. A BASIC stub to start the program would also not count, but it is not allowed to use the stub#s side effects to initialize zeropage addresses.
 ==Winning Entries==

@@ Line 59: / Line 59: @@
 ==Optimized post-deadline versions==
-===34 bytes version for C64===
+===32 bytes version for C64===
-This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column.
+This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column. The executable code size is 32 bytes (filesize 34 bytes).
 <syntaxhighlight lang="6502">
          plot = $E50C    ; Kernal routine moves cursor to (y,x)

← Older revision		Revision as of 09:19, 31 December 2022
Line 55:		Line 55:
	Serato's entry was provided with the following comments:		Serato's entry was provided with the following comments:
	<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki>		<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki>
		+	==Optimized post-deadline versions==
		+	===34 bytes version for C64===
		+	This shorter C64 version by Serato renders the union of four triangles rotated 90 degrees. To save space it iterates 256 times. It also uses a trick where the carry flag state is set by the loop comparison causing the active row to advance automatically at the end of each column.
		+	<syntaxhighlight lang="6502">
		+	plot = $E50C ; Kernal routine moves cursor to (y,x)
		+	sys_h = $15
		+	pnt = $d1
		+	tblx = $d6
		+	* = $c00
		+	lda #22
		+	loop2 tay
		+	loop1 sbc #3
		+	tax
		+	jsr plot
		+	lda #'*'
		+	sta (pnt),y
		+	tya
		+	eor #$1f
		+	ldy tblx
		+	dec $2
		+	bne loop1
		+	dey
		+	cpy #10
		+	bcs loop1
		+	dec sys_h
		+	bpl loop2
		+	rts
		+	</syntaxhighlight>

@@ Line 1: / Line 1: @@
 [[Category:Case Study]]
 ==The challenge==
-During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022] the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed.
+During the [https://demozoo.org/parties/4578/ Vintage Computing Christmas Challenge 2022], the goal was to create the shape of a given Christmas star with as few bytes as possible. All platforms and languages were allowed. The star should look exactly like the one shown below.
 <code>
                 *       *
@@ Line 25: / Line 24: @@
 * draw character by character
 * mirror triangles
-* etc
 ==Winning Entries==
 === Winning entry for C64 ===

← Older revision		Revision as of 20:50, 28 December 2022
Line 27:		Line 27:
	* etc		* etc
	==Winning Entries==		==Winning Entries==
		+	=== Winning entry for C64 ===
		+	The shortest entry for the C64 was submitted by Serato with 34 bytes:
		+	<syntaxhighlight lang="6502">
		+	chrout = $FFD2 ; Kernal routine outputs char in A
		+	plot = $E50C ; Kernal routine moves cursor to (y,x)
		+	pnt = $d1 ; Pointer to the start of the current screen line
		+	row = $b3 ; zp var that always starts at 3
		+	* = $1000
		+	do_2nd ldx row ; render "upside down" triangles
		+	do_line ldy #9 ; render one row of triangle, and its x-mirror image
		+	jsr plot ; move cursor to column 9 on row x
		+	ldy #17 ; start x-mirrored image in column 17
		+	lda #'*' ; the star of the show
		+	do_asks jsr chrout ; print star, advancing kernal cursor to right
		+	sta (pnt),y ; write x-mirrored star with mirrored cursor
		+	dey ; advance mirrored cursor to left
		+	cpy row ; test against line y=x to form diagonal
		+	bne do_asks
		+	cpx row ; check if these weere "upside down" triangles
		+	bne do_2nd ; if not, draw the upside down ones
		+	sys lda #$10 ; entry point of routine, start with y mirrored
		+	sec ; wish this could be avoided, feels like a wasted byte
		+	isc row ; increment bottom row counter and put (16 - row) in A
		+	tax ; we need in x register
		+	bpl do_line ; repeat until row < 0, then fall through
		+	rts
		+	</syntaxhighlight>
		+	Serato's entry was provided with the following comments:
		+	<nowiki>The required octogram may be constructed as the union of four right triangles reflected four ways in x and y axes. The central loop renders one row of the triangle, plus its horizontal mirror image. The outer loop iterates over normal and mirror image screen rows. The result is all four triangles being rendered on top of each other. Saved a byte with unintended 6502 opcode ISC which combines INC and SBC to both increment a counter and load (16 minus) its value into A.</nowiki>