Comet 64

I honestly feel kind of mixed (but towards positive) on this game. It's actually a really good entry to the genre: [list] [*] The UI is good. It's easy to understand what's going on, and why. [*] The puzzles are clear and well-explained. I did not hit a wall because of a vague explanation. [*] The machine is more capable, and program space is plentiful. It feels a real touch more like actual programming, than esoteric puzzles. [/list] But it's not for a lack of problems, almost entirely little things that almost feel mean to nit-pick. It's very normal to have a fixed set of limitations or a difficult machine to program for (it's why most programming games are focused on assembly code and registers!), but here, these small issues feel like design mistakes rather than meaningful and deliberate limitations. [h3]Syntax[/h3] Syntax is not checked until a line is [i]executed[/i]. This means you might be watching your program truck along, only for it to fail for simple syntax on a rare condition. It's easy to fix the program, but it's a small annoyance that would've been easily fixed if syntax was checked dynamically as you typed; something that these games lend well to, since they have internal text editors. Semicolons are present and mandatory, but without syntactic meaning. The code here is line oriented; only one instruction per line -- but, errors are produced (and only found during execution) if semicolons are left out. It's an error to put labels on a line with instructions. This is an issue on diskettes A and B, where program space is limited to prevent hardcoded solutions. A few times I had good solutions be just a line short because of this. Probably the smallest complaint of the syntax, but 'Jump' instructions are a bit verbose and clunky. They add spaces and colons to instruction names, and are completely unique in that. [code] jump to: <label>; jump if true: <label>; jump if false: <label>; [/code] Comparisons are only '=', '<', and '>' -- no combined '<=' or '>='. You get around this by using the opposite comparison and switching your jump's 'true' and 'false', but it's very easy to accidentally only change one: [code] do: <...> while: check reg > 0; jump if true: do; // "oops! forgot to include 0" do: <...> while: check reg > 0; jump if false: do; // "solved" [/code] [h3]Semantics[/h3] The core of the machine involves a set of typed registers, being a float, an integer, a boolean, a character, and a string. Conversions are clean for the most part, but it's annoyingly non-orthogonal: [code] check reg = str[int]; // nope char = str[int]; int = char; check reg = int; // int got bashed // add switches to save it... char = str[int]; switch int; // ...and it errors out here? because there's non-integer data in the 'switch' box? int = char; check reg = int; switch int; switch null; // just gotta bash the switch contents then, no saving them char = str[int]; switch int; int = char; check reg = int; switch int; [/code] There is a 'return' statement which seems useful at first glance, but there's no 'call' instruction nor call stack. Every jump sets the singular return value -- you cannot write functions with jumps. Additionally, the 'return' statement breaks if calling code is not under a label, which further increases your line count if you're trying to code for Diskette A or B. Infinite loop detection is here and I'm glad for it, but it's capable of false alarms. This can be pretty frustrating: you can solve the puzzle, but just about not make it according to a metric you weren't aware of until after you came up with a complete and working solution. One false alarm, and you don't trust it when it triggers for real either, leading you to *think* you need to throw out a solution, when you just got one 'jump' statement flipped the wrong way. [h3]Difficulty[/h3] This isn't a massive complaint to me -- I'm pretty happy to finish games -- but the back half of this game doesn't get particularly challenging. Though you definitely build up skill and familiarity with the machine, and there are absolutely some hard puzzles in here, the difficulty curve isn't nailed down. [h3]Conclusion[/h3] This game is absolutely worth a play if you like programming puzzlers! These are just small mistakes that weigh on me after my playthrough. In my breaks I was definitely excited to come back to this game, and unlike a lot of other entries in the genre, I never hit a wall. These small issues do absolutely weigh on my mind though, and do personally recolor my perception of it a touch.

Comet 64 is a "Programming Puzzle Math" game using assembly-like (low-level language). If you enjoy this type of game, consider playing it.

love the ui

an aquired taste

One of the best i ever played

Fun assembly type game. If you like other assembly games you'll like this one.