Comet 64 All Solutions and 100% Achievements

Comet 64 All Solutions and 100% Achievements

Posted on

For Comet 64 players, if you want to get all achievements in game, this guide provides all solutions for completing the game and obtaining 100% achievements!

 

disk1

Comet 64 All Solutions and 100% AchievementsEnd of Disk 1
Solve all puzzles in Disk 101. 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 / 10;
int = reg + 0.5;
int = int * 10;
output = int;

disk2

Comet 64 All Solutions and 100% AchievementsEnd of Disk 2
Solve all puzzles in Disk 211. Any Leftovers?

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

12. Some Leftovers

begin:
reg = input;
int = reg / 4;
int = int * 4;
int = reg – int;
check int = 3;
jump if false: begin;
output = reg;

13. Differentiator

int = input – input;
check int > 5;
jump if true: main;
check int < -5;
main:
output = bool;

14. Reverse Integeering

reg = input / 10;
int = reg;
reg = reg – int;
reg = reg * 100;
reg = reg + int;
output = reg;

15. Doppelgänger 2

check input = input;
output = bool;

16. Heads & Tails

begin:
reg++;
check input = heads;
jump if true: end;
int++;
end:
check reg = 100;
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;
jump if true: third;
switch int;
int = reg;
switch reg;
third:
switch reg;
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;
switch int;
int = 1;
output = int;
loop:
output = int;
reg = int * 1.62;
int = reg + 0.5;
switch reg;
check int > reg;
switch reg;
jump if false: loop;

disk3

Comet 64 All Solutions and 100% AchievementsEnd of Disk 3
Solve all puzzles in Disk 321. Easier Than It Looks

int = input;
reg = int * int;
int = reg – int;
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 [needs optimization]

str = input;
sort:
reg = str.length;
reg–;
char = str[reg];
int = char;
loop:
reg–;
char = str[reg];
switch reg;
reg = char;
check int < reg;
jump if false: next_a;
switch reg;
reg++;
str[reg] = char;
reg–;
char = int;
str[reg] = char;
jump to: next_b;
next_a:
int = reg;
switch reg;
next_b:
check reg > 0;
jump if true: loop;
reg = str.length;
reg–;
char = str[reg];
int = char;
check:
reg–;
char = str[reg];
switch reg;
reg = char;
check int < reg;
jump if true: sort;
int = reg;
switch reg;
check reg > 0;
jump if true: check;
output = str;

30. Comet LXIV

reg = input / 10;
tens:
check reg < 1;
jump if true: units;
str = str + X;
reg = reg – 1;
jump to: tens;
units:
check reg = 0.4;
jump if true: 4;
check reg = 0.9;
jump if true: 9;
check reg > 0.4;
jump if false: 123;
str = str + V;
reg = reg – 0.5;
123:
check reg = 0;
jump if true: end;
str = str + I;
reg = reg – 0.1;
jump to: 123;
4:
str = str + IV;
jump to: end;
9:
str = str + IX;
end:
output = str;
str = ;

disk4

Comet 64 All Solutions and 100% AchievementsEnd of Disk 4
Solve all puzzles in Disk 431. 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–;
check int < 0;
jump if true: end;
char = str[int];
check char = g;
jump if false: loop;
char = e;
str[int] = char;
jump to: loop;
end:
output = str;

34. Root Input

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 true: out;
jump to: loop;
out:
output = int;
check int = 0;
jump if true: loop;
tail:
reg = input;
check reg = 0;
jump if true: loop;
jump to: tail;

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;
int = int – 1;
jump to: next4;
zero4:
str = str + 0;
next4:
output = str;
str = ;

37. Binary Transition [lines only]

reg = input / 100;
str = ;
loop:
int = reg / 10;
int = int * 10;
reg = reg – int;
int = int / 10;
reg = reg * 10;
switch reg;
reg = reg * 2;
reg = reg + int;
switch reg;
str = str + 1;
check str = 1111;
jump if false: loop;
switch reg;
output = reg;

37. Binary Transition [steps only]

st:
int = input;
check int > 1000;
jump if true: m9;
check int > 100;
jump if true: m5;
check int = 0000;
jump if false: m1;
output = 0;
jump to: st;
m1:
check int = 0001;
jump if false: m2;
output = 1;
jump to: st;
m2:
check int = 0010;
jump if false: m3;
output = 2;
jump to: st;
m3:
check int = 0011;
jump if false: m4;
output = 3;
jump to: st;
m4:
check int = 0100;
jump if false: m5;
output = 4;
jump to: st;
m5:
check int = 0101;
jump if false: m6;
output = 5;
jump to: st;
m6:
check int = 0110;
jump if false: m7;
output = 6;
jump to: st;
m7:
check int = 0111;
jump if false: m8;
output = 7;
jump to: st;
m8:
check int = 1000;
jump if false: m9;
output = 8;
jump to: st;
m9:
check int = 1001;
jump if false: m10;
output = 9;
jump to: st;
m10:
check int = 1010;
jump if false: m11;
output = 10;
jump to: st;
m11:
check int = 1011;
jump if false: m12;
output = 11;
jump to: st;
m12:
check int = 1100;
jump if false: m13;
output = 12;
jump to: st;
m13:
check int = 1101;
jump if false: m14;
output = 13;
jump to: st;
m14:
check int = 1110;
jump if false: m15;
output = 14;
jump to: st;
m15:
output = 15;

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;
jump if false: end;
char = i;
str[reg] = char;
jump to: loop;
end:
output = reg;

40. Let’s Settle This

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

diskA

Comet 64 All Solutions and 100% AchievementsA:\> Completed
Solve all puzzles in Disk AAll puzzles in disks A and B can be cheesed using this code:

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

Simply replace an o with an i if you want to output true. Below, only intended solutions are listed.

A1: full_on

output = true;

A2: one_on

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

A3: one_off

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

A4: striped vertical

output = true;
output = false;

A5: striped_horizontal

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

A6: outer_circle

full:
output = true;
output = true;
output = true;
output = true;
part:
output = true;
output = false;
output = false;
output = true;
int++;
check int = 6;
jump if false: part;

A7: inner_circle

part:
output = false;
output = false;
reg++;
check reg < 4;
jump if true: part;
reg = 0;
full:
output = false;
output = true;
output = true;
output = false;
int++;
check int < 4;
jump if true: full;

A8: forward_slash

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

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

diskB

Comet 64 All Solutions and 100% AchievementsB:\> Completed
B:\> CompletedB1: output_bool

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

B2: checker_board:

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

B3: ascending_order

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

B4: middle_path

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

B5: criss_cross

short:
check int < 3;
jump if false: long;
output = false;
output = false;
output = true;
int++;
reg = 7;
jump to: short;
long:
output = false;
output = false;
output = false;
output = false;
output = true;
reg = reg – 2;
int = reg;

B6: shooting_stars

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

B7: upper_right

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

B8: play_button [needs rework]

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

B9: hiroshima

int = reg;
loop_a:
output = true;
check int > 0;
int–;
jump if true: loop_a;
int = reg;
loop_b:
output = false;
check int > 0;
int–;
jump if true: loop_b;
reg++;

voodoo.txt

Comet 64 All Solutions and 100% AchievementsWhat Sorcery is This?
Enter the correct password to access voodoo.txtAs 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 puzzles of a disk to unlock one of the characters (labeled ‘code’). The achievement unlocks after decrypting the file.

Endings

Comet 64 All Solutions and 100% AchievementsThe Father
Play the real endingComet 64 All Solutions and 100% AchievementsThe Master
Play the secret ending

The game features two ending: “The Father” and “The Master”. For the first one you must solve all puzzles before completing the final level. For the second one you must solve the final level before completing any other puzzle.

Set the username to ‘masterotari’ to gain access to the final level.

99. ErRor [Achievement: Star of Bethlehem]

str = input;
int = str.length;
int–;
char = str[0];
switch char;
char = str[int];
str[0] = char;
switch char;
str[int] = char;
print str;
That’s all we are sharing today in Comet 64 All Solutions and 100% Achievements, if you have anything to add, please feel free to leave a comment below, and we’ll see you soon.
Credit to Hanni and Giraffe

MORE GAME GUIDES FOR YOU

Related Posts:

3 thoughts on “Comet 64 All Solutions and 100% Achievements”

  1. Most of your solutions are much nicer than mine.

    I did want to suggest a slightly more elegant solution to the last challenge of disk 2. Also 12 lines but without the shortcut of using the 1.62 multiplier.

    int = input;
    switch int;
    int = 1;
    reg = 0;
    nextfib:
    output = int;
    int = reg + int;
    reg = int – reg;
    switch reg;
    check int > reg;
    switch reg;
    jump if false: nextfib;

    Reply

  2. Optimized 29.

    str = input;
    compare:
    char = str[reg];
    reg++;
    int = str.length;
    check reg = int;
    jump if true: end;
    int = char;
    char = str[reg];
    switch reg;
    reg = char;
    check int > reg;
    switch reg;
    jump if false: compare;
    char = int;
    str[reg] = char;
    switch int;
    char = int;
    reg–;
    str[reg] = char;
    reg=0;
    jump to: compare;
    end:
    reg=0;
    output = str;

    Reply

  3. #35: Negative Initiative (11 lines, 177 cycles) (definitely room for improvement still)

    start:
    reg = input;
    check reg < 1;
    jump if false: start;
    output = reg;
    check reg = 0;
    jump if true: start;
    next:
    reg = input;
    check reg = 0;
    jump if false: next;

    Reply

Leave a Reply

Your email address will not be published. Required fields are marked *