Comet 64 - Solutions + 100% Achievements

Guidance for completing the game and obtaining 100% achievements!

Introduction

Comet 64 is a fun programming game featuring 59 levels and 13 Steam achievements. This guide provides optimized solutions granting all stars!

There are highly efficient solutions using lookup-tables for some levels. Since they don't grant all stars we list them in a separate section at the end of the guide. Those levels are marked with [LT].

Many thanks to N.G. and Shindo for their additional help!

disk1

End of Disk 1
Solve all puzzles in Disk 1



01. Launch Discount [Achievement: Hello World;]

reg = input * 0.8;
output = reg;

02. Why so Negative?

reg = input * -1;
output = reg;

03. BMI Guest

int = input;
reg = input;
reg = reg * reg;
reg = int / reg;
output = reg;

04. What Goes Up

int++;
output = int;

05. Must Come Down [Achievement: The Holy Trinity]

int++;
reg = 101-int;
output = reg;

06. Compare the Pair

int = input;
reg = input;
check int > reg;
jump if true: print;
int = reg;
print:
output = int;

07. The Doppelgänger

next:
int = input;
check reg = int;
reg = int;
jump if false: next;
output = int;

08. Sum'♥♥♥♥♥

add:
int = input;
check int = 0;
reg = reg + int;
jump if false: add;
output = reg;
reg = 0;

09. Round About

int = input + 0.5;
output = int;

10. Just Around

reg = input / 1000;
int = reg * 1000;
output = int;

disk2

End of Disk 2
Solve all puzzles in Disk 2



11. Any Leftovers?

reg = input;
int = reg / 4;
int = int * 4;
int = reg - int;
output = int;

12. Some Leftovers

start:
reg = input / 4;
int = reg + 0.25;
check reg < int;
jump if false: start;
reg = reg * 4;
output = reg;

13. Differentiator

int = input - input;
int = int * int;
check int > 25;
output = bool;

14. Reverse Integeering

reg = input * 10.1;
int = reg / 100.1;
int = int * 100;
int = reg - int;
output = int;

15. Doppelgänger 2

check input = input;
output = bool;

16. Heads & Tails

begin:
check input = heads;
jump if true: end;
int++;
end:
check input = null;
jump if false: begin;
check int > 50;
jump if true: tails;
check int < 50;
jump if true: heads;
output = draw;
tails:
output = tails;
heads:
output = heads;

17. Big Brother

int = input;
reg = input;
check int < reg;
jump if true: small;
reg = int;
small:
int = input;
check int < reg;
jump if true: second;
reg = int;
second:
output = reg;

18. Middle Brother

int = input;
reg = input;
check int < reg;
switch reg;
jump if true: third;
switch int;
third:
reg = input;
check int > reg;
jump if true: out;
switch int;
check int < reg;
jump if true: out;
int = reg;
out:
output = int;

19. Greatest of Brothers

reg = input;
again:
int = input;
check reg > int;
jump if true: next;
reg = int;
next:
check input = null;
jump if false: again;
output = reg;

20. Golden Spiral

int = input;
reg = 1;
output = 1;
loop:
output = reg;
reg = reg * 0.0162;
reg = reg * 100;
check reg > int;
jump if false: loop;

disk3

End of Disk 3
Solve all puzzles in Disk 3



21. Easier Than It Looks

reg = input - 0.5;
int = reg * reg;
output = int;

22. Harder Than It Looks

reg = input - 0.5;
reg = reg * reg;
reg = reg - 0.25;
output = reg;

23. Give me a Ballpark

loop:
int = int + input;
check input = null;
jump if false: loop;
reg = int / 10;
output = reg;

24. Black Jack

loop:
int = reg;
check input = null;
jump if true: end;
reg = reg + input;
check reg > 21;
jump if false: loop;
end:
output = int;
reg = reg - int;

25. Initial Impression

str = input;
char = str[0];
output = char;

26. Lasting Impression

str = input;
int = str.length - 1;
char = str[int];
output = char;

27. thelongeststring

loop:
check input = null;
jump if true: end;
str = input;
int = str.length;
check int > reg;
jump if false: loop;
reg = int;
switch str;
jump to: loop;
end:
switch str;
output = str;

28. 46temoc

str = input;
int = str.length;
loop:
int--;
char = str[int];
switch str;
str = str + char;
switch str;
check int > 0;
jump if true: loop;
switch str;
output = str;
switch null;

29. 46cemot

str = input;
int = str.length - 1;
check:
reg = int - 1;
char = str[int];
switch int;
int = char;
char = str[reg];
reg = char;
check int < reg;
switch int;
jump if false: continue;
str[int] = char;
reg = int - 1;
switch int;
char = int;
str[reg] = char;
int = str.length;
continue:
int--;
check int < 1;
jump if false: check;
output = str;

30. Comet LXIV [LT]

reg = input;
ten:
check reg > 8;
jump if false: five;
reg = reg - 10;
check reg < 0;
jump if true: minus;
str = str + X;
jump to: ten;
five:
check reg > 3;
jump if false: one;
reg = reg - 5;
check reg < 0;
jump if true: minus;
str = str + V;
one:
check reg > 0;
jump if false: out;
str = str + I;
reg--;
jump to: one;
minus:
str = str + I;
return;
out:
output = str;
str = ;

disk4

End of Disk 4
Solve all puzzles in Disk 4



31. Coordinate Pairs

reg = input;
int = input;
output = reg, int;

32. Paired Coordinates

int = input;
reg = input;
switch reg;
reg = input;
output = int, reg;
switch reg;
int = input;
output = reg, int;

33. Secret Message

str = input;
int = str.length;
loop:
int--;
char = str[int];
check char = g;
jump if false: next;
char = e;
str[int] = char;
next:
check int = 0;
jump if false: loop;
output = str;

34. Root Input [LT]

reg = input;
int = 0;
loop:
int = int + 2;
reg = reg - int;
check reg < 0;
jump if false: loop;
int = int / 2;
output = int;

35. Negative Initiative

loop:
int = input;
check int < 1;
jump if false: loop;
output = int;
check int = 0;
jump if true: loop;
skip:
check input = 0;
jump if false: skip;

36. As Easy As 01 10 11

int = input;
check int > 7;
jump if false: zero1;
str = str + 1;
int = int - 8;
jump to: next1;
zero1:
str = str + 0;
next1:
check int > 3;
jump if false: zero2;
str = str + 1;
int = int - 4;
jump to: next2;
zero2:
str = str + 0;
next2:
check int > 1;
jump if false: zero3;
str = str + 1;
int = int - 2;
jump to: next3;
zero3:
str = str + 0;
next3:
check int > 0;
jump if false: zero4;
str = str + 1;
jump to: next4;
zero4:
str = str + 0;
next4:
output = str;
str = ;

37. Binary Transition [LT]

reg = input + 404;
reg = reg / 100;
int = reg;
reg = reg - int;
reg = reg * 100;
switch reg;
int = int / 5;
int = int * 4;
switch reg;
reg = reg / 5;
int = int + reg;
output = int;

38. No Duplicates!

loop:
int = int + input;
check input = null;
jump if false: loop;
int = int - 45;
output = int;

39. No Duplicates!

str = oooooooooo;
loop:
reg = input;
char = str[reg];
check char = o;
char = i;
str[reg] = char;
jump if true: loop;
output = reg;

40. Let's Settle This

str = input;
int = str.length;
str = input;
int = int + str.length;
str = paper;
check int = 9;
jump if true: out;
str = rock;
check int = 12;
jump if true: out;
str = scissors;
check int = 13;
jump if true: out;
str = draw;
out:
output = str;

diskA

A:\> Completed
Solve all puzzles in Disk A



A1: full_on [LT]

output = true;

A2: one_on [LT]

check int = 0;
output = bool;
int++;

A3: one_off [LT]

check int < 31;
output = bool;
int++;

A4: striped vertical [LT]

output = true;
output = false;

A5: striped_horizontal [LT]

output = true;
output = true;
output = true;
output = true;
output = false;
output = false;
output = false;
output = false;

A6: outer_circle [LT]

reg = int / 70;
reg = reg * 70;
check int = reg;
output = true;
output = bool;
output = bool;
output = true;
int++;

A7: inner_circle [LT]

int = reg + 2;
int = int / 4;
check int = 1;
output = false;
output = bool;
output = bool;
output = false;
reg++;

A8: forward_slash [LT]

output = false;
output = false;
output = false;
line:
output = true;
output = false;
output = false;
int++;
check int = 4;
jump if false: line;
int = 0;
output = false;

A9: back_slash [LT]

line:
output = true;
output = false;
output = false;
output = false;
output = false;
int++;
check int = 3;
jump if false: line;
output = true;

diskB

B:\> Completed
B:\> Completed



B1: output_bool [LT]

check int > 12;
output = bool;
int++;

B2: checker_board [LT]

output = true;
output = false;
output = true;
output = false;
output = false;
output = true;
output = false;
output = true;

B3: ascending_order [LT]

int = reg;
output = true;
repeat:
output = false;
int--;
check int > -1;
jump if true: repeat;
reg++;

B4: middle_path [LT]

output = false;
output = true;
output = true;
output = false;
output = false;
output = false;
output = false;

B5: criss_cross [LT]

left:
output = false;
output = false;
output = true;
int++;
check int < 3;
jump if true: left;
right:
output = false;
output = false;
output = false;
output = false;
output = true;
int--;
check int > 0;
jump if true: right;

B6: shooting_stars [LT]

output = false;
output = false;
output = true;

B7: upper_right [LT]

row:
int++;
check int > reg;
output = bool;
check int < 4;
jump if true: row;
int = 0;
reg++;
check reg < 4;
jump if true: row;
reg = 0;

B8: play_button [LT]

start:
reg++;
check char = y;
jump if false: row;
reg = reg - 2;
row:
check int < reg;
output = bool;
int++;
check int < 4;
jump if true: row;
int = 0;
check reg = 4;
jump if false: start;
char = y;
reg = reg + 0.1;

B9: hiroshima [LT]

int++;
one:
output = true;
reg++;
check reg = int;
jump if false: one;
zero:
output = false;
reg--;
check reg = 0;
jump if false: zero;

voodoo.txt

What Sorcery is This?
Enter the correct password to access voodoo.txt



As you may have already noticed the voodoo file is encrypted. The password was randomly generated upon starting the game for the first time. Complete all levels of a disk to unlock one of the characters (labeled 'code'). The achievement unlocks after decrypting the file.

Endings

The Father
Play the real ending


The Master
Play the secret ending



The game features two ending: 'The Father' and 'The Master'. For the first one you have to solve all 58 levels before completing the final level. For the second one you have to solve less than 58 levels before completing the final level (delete/backup your local save files if necessary).

Set the login username to masterotari to gain access to the final level.

99. ErRor [Achievement: Star of Bethlehem]

str = input;
int = str.length - 1;
char = str[0];
switch char;
char = str[int];
str[0] = char;
switch char;
str[int] = char;
print str;

Lookup-Tables

Some levels can be solved using lookup-tables. Since they don't grant all stars we list them here.

30. Comet LXIV

str = ooooooioooooiiooooiiioooivoooovoooooviooooviioooviiiooixooooxoooooxiooooxiioooxiiiooxivoooxvooooxvioooxviiooxviiioxixoooxxoooo;
int = input * 6;
switch null;
loop:
char = str[int];
check char = o;
jump if true: end;
switch str;
str = str + char;
switch str;
int++;
jump to: loop;
end:
switch str;
output = str;

34. Root Input

str = xaxxbxxxxcxxxxxxdxxxxxxxxexxxxxxxxxxfxxxxxxxxxxxxgxxxxxxxxxxxxxxhxxxxxxxxxxxxxxxxixxxxxxxxxxxxxxxxxxj;
int = input;
char = str[int];
int = char;
output = int;

37. Binary Transition

str = abxxxxxxxxcdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxefxxxxxxxxghxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxijxxxxxxxxklxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxmnxxxxxxxxop;
int = input;
char = str[int];
int = char;
int = int - 1;
output = int;

diskA and diskB: // replace an o with an i in the first line if you want to output true

str = oooooooooooooooooooooooooooooooo;
char = str[reg];
check char = i;
output = bool;
reg++;

[DeathHero®]

THX

[Giraffe]

@wrxmarcus I forgot who added the solution for #20 but 0.0162 seems to be an approximation of the golden ratio (1.618033988749...) divided by 100 (0.01618033988749...). The golden ratio and the fibonacci numbers are mathematically related, see https://en.wikipedia.org/wiki/Fibonacci_sequence#Relation_to_the_golden_ratio (warning: lots of math). If I am not mistaken, Numberphile also has a more digestible video about that relationship.

[wrxmarcus]

For #20 The Golden Spiral -- I need to know how someone came up with reg = reg * 0.0162;?
Where does 0.0162 come from? How many Fn will this work? I'm at a complete loss as to how you go this number. thanks!

[MLP]

Thank you, WeRGoN!
Left the game for some time

[WeRGoN]

@__theClaw();, Your solution is indeed a bit faster, but the main thing is that it is less hacky (looks like intended way). That's why I updated the guide with your code.

It's funny, that in my time I didn't find such a simple solution through rounding in the INT, but went into the wilderness of the REG. xD

[WeRGoN]

@MLP, Explanation of 12. Some Leftovers.

Our task is to separate a specific remainder of division from the rest ones. In this case, we cut off all the wrong options in 2 steps.

1) We want to cut off half of the options by rounding (we will use the ability of the REG to round to 2 decimal places). So, we need to divide the number by 4 and we have to divide by another 100 to round result. Let's divide row {1, 2, 3, 4} by 400.
{1, 2, 3, 4} / 400 = {0.0025, 0.005, 0.0075, 0.01} (with rounding = {0, 0.01, 0.01, 0.01})

Not the best result, since we were only able to cut off one wrong number. But 0.005 is right on the edge of rounding. We can easily and without consequence make it round down.
{1, 2, 3, 4} / 401 = {0.0024.., 0.0049.., 0.0074.., 0.099..} (with rounding = {0, 0, 0.01, 0.01})

[WeRGoN]

2) We need to learn how to separate the remainder of 3 from 0. The only option is to use the original value, which is stored in INT. Let's try just multiplying by 400 and compare the numbers.
{0, 0, 0.01, 0.01} * 400 = {0, 0, 4, 4} (with INPUT = {1, 2, 3, 4})
If we compare the two sequences (REG = {0, 0, 4, 4} and INT = {1, 2, 3, 4}), we can already make a simple conclusion:
"REMAINDER = 3 if REG > INT"

Thus 400 is sufficient. But I didn't notice it at the time and put 399 to be sure. xD

[MLP]

@WeRGoN
Great guide!
I wanted to ask about the problem 12 . Some Leftovers

Why is used X/401 and then multiplied by 399? I get that it has to do with leaving the two significant decimals to round the number, but I fail to see why those numbers are used nor the maths behind...

Thank you in advance!

[__theClaw();]

Here's a more optimised solution to 12. Some Leftovers (solution by me):

[code]
start:
reg = input / 4;
int = reg + 0.25;
check reg < int;
jump if false: start;
reg = reg * 4;
output = reg;
[/code]

[theboardgamer]

@giraffe --- hmm I tried again and your solution works fine. Must be a copy-paste, user (me) error. Thanks for checking and making this wonderful guide.